srl.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref filter::limiter::SRL class, which implements
 * a discrete-time slew-rate limiter.
 *
 * A slew-rate limiter restricts how quickly an output signal can increase
 * or decrease. It limits the rate of change of the output between two
 * consecutive samples to a configurable minimum and maximum value.
 *
 * The limiter is useful for signal conditioning and for preventing
 * commands from changing faster than a physical system can safely
 * respond.
 *
 * The class is templated to support different numeric types such as
 * @c float and @c double.
 *
 * @tparam T Numeric data type used for the limiter calculations.
 *
 * @author Abhinay Kumar
 * @version 1.0.0
 *
 * @copyright
 * Copyright (c) 2026 Abhinay Kumar
 */
 
#ifndef FILTER_SRL
#define FILTER_SRL
 
namespace filter
{
 
    namespace limiter
    {

         * maximum slew rates.
         *
         * The rate limits are specified in units of signal units per
         * second.
         *
         * @tparam T Numeric data type used for the limiter.
         *
         * @par Example
         * @code{.cpp}
         * filter::limiter::SRL<double> limiter;
         *
         * limiter.config(
         *     0.001,    // Sampling time [s]
         *     -10.0,    // Minimum slew rate [units/s]
         *      10.0     // Maximum slew rate [units/s]
         * );
         *
         * double output = limiter.update(input);
         * @endcode
         */
        template <typename T>
        class SRL
        {
        public:
             * @brief Constructs a slew-rate limiter.
             *
             * @details
             * Constructs the limiter with its parameters and internal
             * state initialized to their default values.
             */
            SRL();


             * @param[in] dx_dt_min_ Minimum allowed rate of change.
             * @param[in] dx_dt_max_ Maximum allowed rate of change.
             *
             * @details
             * Configures the sampling time and the minimum and maximum
             * allowable rates of change of the output signal.
             */
            void config(T dt_, T dx_dt_min_, T dx_dt_max_);


            void set_param(T dt_, T dx_dt_min_, T dx_dt_max_);

            T update(T x_k);

            void reset();

            void set_dt(T dt_);

            void set_dx_dt_min(T dx_dt_min_);

            void set_dx_dt_max(T dx_dt_max_);

            T get_dt();

            T get_dx_dt_min();

            T get_dx_dt_max();

            T get_fs();
 
        private:
            T dt = 0;

            T dx_dt_min = 0;

            T dx_dt_max = 0;

            T y_k_1 = 0;

            bool start = false;
        };
 
#include "../../src/limiter/srl.tpp"
    } // namespace limiter
 
} // namespace filter
 
#endif // FILTER_SRL