pd_lpf_1.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref control_system::pd::PD_LPF_1 class, which
 * implements a discrete-time proportional-derivative (PD) controller
 * with a first-order low-pass filter associated with the derivative
 * action.
 *
 * The controller uses configurable proportional and derivative gains,
 * sampling time, derivative filter cutoff frequency, and maximum output
 * limit.
 *
 * The previous control error and controller output are maintained as
 * internal state variables.
 *
 * @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_PD_PD_LPF_1_H
#define CONTROL_SYSTEM_PD_PD_LPF_1_H
 
#include "../utility/utility.h"
 
namespace control_system
{
 
    namespace pd
    {


         * associated with the derivative action.
         *
         * The controller uses the sampling time, proportional gain,
         * derivative gain, and derivative filter cutoff frequency to
         * calculate the control output.
         *
         * The controller maintains the previous control error and
         * controller output as internal state and applies a configurable
         * maximum output limit.
         *
         * @tparam T Numeric data type used for the controller.
         *
         * @par Example
         * @code{.cpp}
         * control_system::pd::PD_LPF_1<double> controller;
         *
         * controller.init(
         *     0.001,
         *     Kp,
         *     Kd,
         *     10.0,
         *     100.0
         * );
         *
         * double output = controller.update(reference, measurement);
         * @endcode
         */
        template <typename T>
        class PD_LPF_1
        {
        public:
            /**
             * @brief Constructs a PD controller with filtered derivative.
             *
             * @details
             * Constructs the controller with its parameters and internal
             * state initialized to their default values.
             */
            PD_LPF_1();


             * @param[in] dt_ Controller sampling time in seconds.
             * @param[in] Kp_ Proportional gain.
             * @param[in] Kd_ Derivative gain.
             * @param[in] fc_ Derivative filter cutoff frequency in Hz.
             * @param[in] u_max_ Maximum allowed controller output.
             *
             * @details
             * Initializes the controller sampling time, proportional and
             * derivative gains, derivative filter cutoff frequency, and
             * output limit.
             */
            void init(T dt_, T Kp_, T Kd_, T fc_, T u_max_);


             * @param[in] Kd_ Derivative gain.
             * @param[in] fc_ Derivative filter cutoff frequency in Hz.
             * @param[in] u_max_ Maximum allowed controller output.
             *
             * @details
             * Updates the controller sampling time, proportional and
             * derivative gains, derivative filter cutoff frequency, and
             * output limit.
             */
            void set_param(T dt_, T Kp_, T Kd_, T fc_, T u_max_);

             * @brief Computes the PD control output.
             *
             * @param[in] x_0 Reference or desired value.
             * @param[in] x Current or measured value.
             *
             * @return PD controller output limited by the configured
             * maximum output.
             *
             * @details
             * Calculates the proportional and derivative contributions
             * using the current and previous control errors. The
             * derivative action is associated with a first-order
             * low-pass filter.
             */
            T update(T x_0, T x);

            void reset();

            void merge(T u_k_1_);

            void set_dt(T dt_);

            void set_Kp(T Kp_);

            void set_Kd(T Kd_);

            void set_fc(T fc_);

            void set_u_max(T u_max_);

            T get_dt();

            T get_Kp();

            T get_Kd();

            T get_fc();

            T get_e_k_1();

            T get_u_k_1();

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

            T e_k_1 = 0.0;

            T Kp = 0.0;

            T Kd = 0.0;

            bool start = true;

            T u_k_1 = 0.0;

            T tau = 0.0;

            T u_max = 9999999999;
        };
 
#include "../../src/pd/pd_lpf_1.tpp"
    }
}
 
#endif