Scribd Logo
Upload

Welcome to Scribd!

  • 9 views

    C++ Implementation

    Uploaded by

    Zubaid Satti
    The document describes a C++ implementation of a simple moving average (SMA) filter that improves computational efficiency over a naive direct implementation of the difference equation. It does this by rewriting the difference equation so that only two terms change each time step, allowing updates with one addition and one subtraction instead of N-1 additions. The implementation uses a circular buffer to store previous input values and calculates a rounded average at each time step. An example Arduino code is provided to apply the SMA filter to analog sensor readings.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    C++ Implementation

    Uploaded by

    Zubaid Satti
    9 views2 pages
    The document describes a C++ implementation of a simple moving average (SMA) filter that improves computational efficiency over a naive direct implementation of the difference equation. It does this by rewriting the difference equation so that only two terms change each time step, allowing updates with one addition and one subtraction instead of N-1 additions. The implementation uses a circular buffer to store previous input values and calculates a rounded average at each time step. An example Arduino code is provided to apply the SMA filter to analog sensor readings.

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document describes a C++ implementation of a simple moving average (SMA) filter that improves computational efficiency over a naive direct implementation of the difference equation. It does this by rewriting the difference equation so that only two terms change each time step, allowing updates with one addition and one subtraction instead of N-1 additions. The implementation uses a circular buffer to store previous input values and calculates a rounded average at each time step. An example Arduino code is provided to apply the SMA filter to analog sensor readings.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    9 views2 pages

    C++ Implementation

    Uploaded by

    Zubaid Satti
    The document describes a C++ implementation of a simple moving average (SMA) filter that improves computational efficiency over a naive direct implementation of the difference equation. It does this by rewriting the difference equation so that only two terms change each time step, allowing updates with one addition and one subtraction instead of N-1 additions. The implementation uses a circular buffer to store previous input values and calculates a rounded average at each time step. An example Arduino code is provided to apply the SMA filter to analog sensor readings.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 2

    04/12/2023, 21:24 C++ Implementation

    C++ Implementation
    Pieter P

    Simplifying the Difference Equation

    Recall the Simple Moving Average difference equation:

    N −1
    1
    y[n] = ∑ x[n − i] (1)
    N
    i=0

    A naive approach would be to implement the difference equation directly: keeping the last N − 1 inputs, and calculate the sum on
    each iteration, calculating N − 1 additions at each time step.
    However, we can do much better if we notice how only two terms of the sum change each time:

    N −1
    1
    y[n + 1] = ∑ x[n + 1 − i]
    N
    i=0

    N −1
    1
    = (x[n + 1] + ∑ x[n + 1 − i])
    N
    i=1

    N −1
    1
    = (x[n + 1] + ∑ x[n + 1 − i] + x[n + 1 − N ] − x[n + 1 − N ])
    N
    i=1

    N
    1
    = (x[n + 1] + ∑ x[n + 1 − i] − x[n + 1 − N ])
    N
    i=1

    N −1
    1
    = (x[n + 1] + ∑ x[n − i] − x[n + 1 − N ])
    N
    i=0

    1
    = y[n] + (x[n + 1] − x[n + 1 − N ])
    N

    We can now define the sum S[n] as follows:

    S[n] ≜ N ⋅ y[n]

    N −1

    = ∑ x[n − i]

    i=0

    ⇔ y[n] = S[n]/N

    The difference equation then becomes:

    S[n + 1] = S[n] + x[n + 1] − x[n + 1 − N ] (2)

    To update the sum, each iteration now requires only one addition and one subtraction, as well as some housekeeping to remember
    the previous inputs. To get the output y[n], a division by N is needed.

    C++ Implementation

    We can now implement Equation 2 directly, and we'll use a rounding division instead of truncating the quotient. Note that this
    rounding operation is valid for unsigned integer types only.
    The previous inputs x[n − i] are kept in a circular buffer.

    https://tttapa.github.io/Pages/Mathematics/Systems-and-Control-Theory/Digital-filters/Simple Moving Average/C++Implementation.html 1/2


    04/12/2023, 21:24 C++ Implementation

    SMA.cpp
    1 #include <stdint.h>
    2
    3 template <uint8_t N, class input_t = uint16_t, class sum_t = uint32_t>
    4 class SMA {
    5 public:
    6 input_t operator()(input_t input) {
    7 sum -= previousInputs[index];
    8 sum += input;
    9 previousInputs[index] = input;
    10 if (++index == N)
    11 index = 0;
    12 return (sum + (N / 2)) / N;
    13 }
    14
    15 static_assert(
    16 sum_t(0) < sum_t(-1), // Check that `sum_t` is an unsigned type
    17 "Error: sum data type should be an unsigned integer, otherwise, "
    18 "the rounding operation in the return statement is invalid.");
    19
    20 private:
    21 uint8_t index = 0;
    22 input_t previousInputs[N] = {};
    23 sum_t sum = 0;
    24 };

    Arduino Example

    As a basic example, you can use this filter for smoothing analog inputs on microcontrollers. Keep in mind that an exponential
    moving average filter is often more appropriate than a simple moving average filter. The SMA uses much more memory, and is
    much slower than the EMA. The exponential impulse response of the EMA may be better as well.
    You can find an Arduino example using an EMA here.

    1 template <uint8_t N, class input_t = uint16_t, class sum_t = uint32_t>


    2 class SMA {
    3 public:
    4 input_t operator()(input_t input) {
    5 sum -= previousInputs[index];
    6 sum += input;
    7 previousInputs[index] = input;
    8 if (++index == N)
    9 index = 0;
    10 return (sum + (N / 2)) / N;
    11 }
    12
    13 static_assert(
    14 sum_t(0) < sum_t(-1), // Check that `sum_t` is an unsigned type
    15 "Error: sum data type should be an unsigned integer, otherwise, "
    16 "the rounding operation in the return statement is invalid.");
    17
    18 private:
    19 uint8_t index = 0;
    20 input_t previousInputs[N] = {};
    21 sum_t sum = 0;
    22 };
    23
    24 void setup() {
    25 Serial.begin(115200);
    26 while (!Serial);
    27 }
    28
    29 const unsigned long interval = 10000; // 100 Hz
    30
    31 void loop() {
    32 static SMA<20> filter;
    33 static unsigned long prevMicros = micros();
    34 if (micros() - prevMicros >= interval) {
    35 int rawValue = analogRead(A0);
    36 int filteredValue = filter(rawValue);
    37 Serial.print(rawValue);
    38 Serial.print('\t');
    39 Serial.println(filteredValue);
    40 prevMicros += interval;
    41 }
    42 }

    https://tttapa.github.io/Pages/Mathematics/Systems-and-Control-Theory/Digital-filters/Simple Moving Average/C++Implementation.html 2/2

    You might also like

    pFad - Phonifier reborn

    Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

    Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


    Alternative Proxies:

    Alternative Proxy

    pFad Proxy

    pFad v3 Proxy

    pFad v4 Proxy