ma.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref filter::low_pass::MA class, which implements
 * a moving-average low-pass filter using a fixed-size sliding window.
 *
 * The filter maintains a window of the most recent @p N input samples
 * and calculates their average to produce the filtered output.
 *
 * The window size @p N is specified at compile time.
 *
 * A larger window provides stronger smoothing but introduces greater
 * delay and reduces the effective bandwidth of the filter.
 *
 * @tparam T Numeric data type used for filter calculations.
 * @tparam N Number of samples in the moving-average window.
 *
 * @author Abhinay Kumar
 * @version 1.0.0
 *
 * @copyright
 * Copyright (c) 2026 Abhinay Kumar
 */
 
#ifndef FILTER_MA_1
#define FILTER_MA_1
 
#include <cstdint>
#include <cmath>
 
namespace filter
{
 
    namespace low_pass
    {


         * @details
         * The MA class implements a moving-average filter using a
         * compile-time fixed-size window.
         *
         * At each update, the newest input sample is added to the
         * window and the oldest sample is removed. The output is
         * calculated as the average of the samples currently stored
         * in the window.
         *
         * The number of samples in the window is specified by the
         * @p N template parameter.
         *
         * The filter is useful for reducing high-frequency noise and
         * smoothing sensor measurements.
         *
         * @tparam T Numeric data type used for filter calculations.
         * @tparam N Number of samples in the moving-average window.
         *
         * @par Example
         * @code{.cpp}
         * constexpr uint16_t N = 10;
         *
         * filter::low_pass::MA<double, N> filter;
         *
         * filter.config(0.001);
         *
         * double output = filter.update(input);
         * @endcode
         */
        template <typename T, uint16_t N>
        class MA
        {
        public:

             * Constructs the filter with its parameters and internal
             * state initialized to their default values.
             */
            MA();

             * @brief Configures the moving-average filter.
             *
             * @param[in] dt_ Sampling time in seconds.
             *
             * @details
             * Configures the filter using the specified sampling time.
             */
            void config(T dt_);

            void set_param(T dt_);

            T update(T x_k);

            void reset();

            void set_dt(T dt_);

            T get_fc();

            T get_dt();

            uint16_t get_n();

            T get_fs();

            T get_K(uint16_t N_);

            uint16_t estimate_N_min(T fc_, T dt_);

            uint16_t estimate_N_max(T fc_, T dt_);
 
        private:
            T n = T(N);

            uint16_t index = 0;

            T sum = 0;

            T dt = 0.0;

            T x_arr[N];

            uint16_t start_counter = 0;
        };
 
#include "../../src/low_pass/ma.tpp"
    } // namespace low_pass
 
} // namespace filter
 
#endif // FILTER_MA_1