Read Analog Signal Input From Arduino and Filter Software

Lesson 1: Smoothing Input

Tabular array of Contents

Noisy input
Moving window filters
1. Moving average filter
  1. Arduino implementation
  2. Arduino code
  3. Unproblematic C++ grade
2. Weighted moving average
3. Exponential moving average
  1. Arduino EWMA implementation
4. Moving median filter
5. Why use a median filter?
Other filters
Activity
Arduino filtering libraries
Resources

By now, you may have noticed that your analog input information can be noisy. How can we smoothen our input and what factors should we consider?

Video Smoothing an analog input signal using a moving boilerplate filter with window size of 10. The raw analog input is shown in blue; the smoothed data is shown in red. Graph made with the built-in Arduino Series Plotter.

This is a big, complex question. Indeed, at that place is an entire field chosen digital signal processing (DSP), which explores techniques to sample, shine, or otherwise transform signals, like sensor data, into more usable forms. In indicate processing, filters refer to algorithmic methods and/or hardware approaches to remove or attenuate unwanted components of a signal.

In this lesson, we will cover a form of digital filters called smoothing algorithms (aka signal filters), why they're helpful, and potential tradeoffs in their implementation and apply.

Swoop DEEPER:

DSP is a vast, complex area just even simple signal processing techniques like those covered in this lesson are helpful. If you'd like to dive deeper into DSP, meet our Point Processing lessons, which innovate quantization and sampling, signal comparisons, and frequency analysis. For a more technical introduction to digital filters, see Affiliate 14: Introduction to Digital Filters in Steven West. Smith'due south book The Scientist and Engineer's Guide to Digital Signal Processing. We also recommend Jack Schaelder'southward interactive primer on DSP.

Noisy input

When reading sensor information using analog input pins on a microcontroller (eastward.g., via analogRead on the Arduino), there are many sources of noise, including electromagnetic interference, sensor noise, mechanical noise (for electro-mechanical sensors like potentiometers), stray capacitance, unstable voltage sources, and/or small imperfections in the ADC. Oh my!

Even with a unproblematic potentiometer, nosotros can notice noise on our input pin. In the video below, nosotros are non touching the potentiometer and yet the analog input is oscillating between 142 and 143 (0.694V and 0.699V)—shown as the blue line. Yous may have experienced this too in your own potentiometer-based projects or in the Arduino potentiometer lesson. In this case, nosotros fixed this "input noise" by smoothing the betoken using a moving average filter—shown in reddish—which we will draw in this lesson.

Video. In this video, we're graphing the raw analog input (blue line) from a potentiometer along with a "smoothed" version (red line). Although we're not touching or using the potentiometer, the analog input is aquiver between 142 and 143 (0.694V and 0.699V). We smooth this noise using a moving average filter (window size = 10)—shown in reddish. Notation that, depending on the oscillation blueprint, a different window size or smoothing approach may exist necessary. Read more nearly potentiometer racket hither. Graph made with the born Arduino Serial Plotter.

In addition to smoothing a potentiometer input signal with a digital filter (a software solution), we could, instead, utilize a hardware solution: add in a modest ceramic capacitor (0.1µF or 0.47 µF) from the potentiometer wiper to ground. Still, the focus of this lesson is on software solutions (putting the digital in DSP).

Moving window filters

The most common digital filters utilise a moving window (or buffer) to smooth a betoken in realtime. Typically, larger window sizes result in a "smoother" simply more distorted signal. Larger windows also incur "lag"—the filtered signal's responsiveness to changes in the raw signal—and require more storage and ciphering fourth dimension.

As each sensor and physical computing project is unique, nosotros encourage y'all to experiment with unlike smoothing algorithms and window sizes to reach your desired behavior.

SPECIAL Case: DATA LOGGING

Note that if you're logging data (east.g., to a storage carte du jour or the cloud) for research or data experiments, it's often best to first capture and transmit the raw data so that yous can experiment with signal processing approaches post hoc (e.1000., offline in Jupyter Notebook). Through offline assay with these raw logs, y'all can determine an ideal sampling frequency and filtering arroyo for your item hardware components and trouble domain. Then, you tin implement this approach in your field-deployed organization, which tin can event in reduced computational overhead, bandwidth, power, etc..

Moving boilerplate filter

The most common filter in DSP is the moving boilerplate filter (or moving mean filter), which slides a window of size $Due north$ over a raw signal, computes the average over that window, and uses this average equally the smoothed value.

\[MA=\frac{X_{1} + X_{2} + \ldots + X_{North}}{N}\]

This filter is a blazon of depression-pass filter because it smooths out (eliminates) the high frequency oscillations in the point.

Y'all can command the filter's performance by tweaking the size of the sliding window. The blitheness below demonstrates a sliding window of size three. The blue line corresponds to the raw input indicate; the orangish line, the smoothed filter output. For illustrative purposes, we but show the sliding window applied to a subset of data.

Video This video illustrates a moving average filter of window size 3 over a subset of data. Animation fabricated in PowerPoint.

Despite its simplicity, a moving average filter ofttimes all you will demand in your physical calculating projects. This, of class, depends on your use context and the underlying sensors + circuit setup. Thus, we encourage you to play effectually with various smoothing approaches and tuning parameters. If y'all're sampling a sensor 20 times per 2d (~20Hz), so a window size of 10 will capture roughly 500ms of data. So, it may exist useful to think in terms of time rather than samples.

Below, nosotros compute three different moving average filter window sizes: 5, 10, and 20 and bear witness the resulting filter output in red, greenish, and yellow, respectively.

Video This video graphs raw analog input (bluish) and filtered output from three different moving average window sizes: v (red line), 10 (light-green), and 20 (xanthous). To produce this video, we used this code and the Arduino Serial Plotter. You should try information technology yourself!

Arduino implementation

The official Arduino signal smoothing tutorial uses a moving boilerplate filter. Cleverly, their code uses an optimization (which we infringe below) to avert iterating over the entire window to compute each new average. Instead, nosotros simply decrease the least recent reading in our sliding window from a running full. The code also uses a circular buffer to eliminate needless memory allocations, which is important on constrained systems like microcontrollers.

                          // read the sensor value              int              sensorVal              =              analogRead              (              SENSOR_INPUT_PIN              );              // subtract the last reading from our sliding window              _sampleTotal              =              _sampleTotal              -              _samples              [              _curReadIndex              ];              // add together in electric current reading to our sliding window              _samples              [              _curReadIndex              ]              =              sensorVal              ;              // add the reading to the total              _sampleTotal              =              _sampleTotal              +              _samples              [              _curReadIndex              ];              // calculate the average:              _sampleAvg              =              _sampleTotal              /              SMOOTHING_WINDOW_SIZE              ;              // advance to the next position in the array              _curReadIndex              =              _curReadIndex              +              i              ;              // if we're at the finish of the array...              if              (              _curReadIndex              >=              SMOOTHING_WINDOW_SIZE              )              {              // ...wrap around to the beginning:              _curReadIndex              =              0              ;              }

Arduino code

Our full implementation:

Simple C++ class

Signal filtering is a perfect opportunity to create a class to hide complexity, avert lawmaking back-up, and handle information processing. In our Makeability Lab Arduino Library, nosotros created the MovingAveragefilter.hpp class, which simplifies using a moving average filter. Just yous could make your own, of course, or use other libraries

Here'due south a demonstration of how to use MovingAveragefilter.hpp:

Nosotros also employ the MovingAveragefilter.hpp form in our demonstration of various sliding window sizes on the moving average output (code here).

Weighted moving average

In the moving boilerplate algorithm above, we assign equal weight to all data in our filter window. Y'all could imagine, however, designing an algorithm that assigns higher weights to more than recent information (with the theory that recency correlates to relevancy). And, indeed, there are a grade of algorithms chosen weighted moving averages (WMA) that do just this, including linear weighting schemes with weights that drop off linearly in the filter window and exponential weighting schemes where weights drop off exponentially.

Recall that a regular moving boilerplate is:

\[MA=\frac{X_{i} + X_{2} + \ldots + X_{N}}{Northward}\]

Then the weighted version is simply:

\[WMA=\frac{w_{1}X_{1} + w_{ii}X_{2} + \ldots + w_{n}X_{north}}{w_{1} + w_{2} + \ldots + w_{n}}\]

If the weight coefficients are precomputed to sum to one ($\sum_{i=1}^{due north} w_{i} = 1$), then the above equation but becomes:

\[WMA=w_{1}X_{1} + w_{2}X_{2} + \ldots + w_{n}X_{n}\]

Below, we've included sample weights for both linear and exponential weighting schemes with a sliding window size of fifteen.

Effigy. Images from Wikipedia.

Exponential moving average

Interestingly, you can implement the exponential moving average (EMA)—besides known as the exponentially weighted moving average (EWMA)—without storing a sliding window buffer! This is a very cool optimization and ways that you tin achieve smoothing without the retention and computation overhead of many other "moving" filter techniques.

The algorithm is:

\[S_{i} = \brainstorm{cases} X_{1} & \text{if i = 1}\\ \alpha \cdot X_{i} + (1 - \alpha) \cdot S_{i-i} & \text{if i $>$ ane} \cease{cases}\]

Where:

The coefficient $\alpha$ represents the caste of weighting decrease between 0 and ane. A college $\alpha$ discounts older observations faster.
$X_{i}$ is the value at alphabetize i.
$S_{i}$ is the value of the EMA at index i.

The coefficient $\alpha$ determines the exponential dropoff. A higher $\alpha$ weights more than contempo data more. For example, the video below shows EWMA performance with $\alpha$ equal to 0.five (reddish line), 0.one (green line), and 0.01 (yellow line). Notice how closely the $\alpha=0.5$ EWMA filter tracks the underlying raw betoken whereas the $\alpha=0.01$ filter is quite distorted and lagged. The $\alpha=0.1$ filter may still exist appropriate, depending on your needs. Once again, it'southward upward to you to experiment!

Video This video shows EWMA performance with $\alpha$ equal to 0.5 (reddish line), 0.ane (dark-green line), and 0.01 (yellow line). The code used to produce this video is hither. Graph made with the built-in Arduino Serial Plotter.

Arduino EWMA implementation

If you're not used to reading equations, and so perhaps the Arduino code below is more clear. The algorithm is quite straightforward and, once again, unlike the traditional moving average algorithm, does not require a window buffer!

                          const              int              SENSOR_INPUT_PIN              =              A0              ;              bladder              _ewmaAlpha              =              0              .              ane              ;              // the EWMA alpha value (α)              double              _ewma              =              0              ;              // the EWMA consequence (Si), initialized to nix              void              setup              ()              {              Serial              .              begin              (              9600              );              // for press values to console              _ewma              =              analogRead              (              SENSOR_INPUT_PIN              );              //prepare EWMA (S1) for index 1              }              void              loop              ()              {              int              sensorVal              =              analogRead              (              A0              );              // returns 0 - 1023 (due to 10 scrap ADC)              // Utilize the EWMA formula                            _ewma              =              (              _ewmaAlpha              *              sensorVal              )              +              (              1              -              _ewmaAlpha              )              *              _ewma              ;              Serial              .              print              (              sensorVal              );              Series              .              print              (              ","              );              Serial              .              println              (              _ewma              );              delay              (              50              );              // Reading new values at ~20Hz              }

Code. This lawmaking is on GitHub.

Moving median filter

A moving median filter is nigh the exact same as a moving average filter but takes the median over the sliding window rather than the average.

Video This video shows a moving median filter with a window size of three. Animation made in PowerPoint.

The challenge, however, is calculating the median efficiently. The median is simply the centre value of a sorted array $X_s$ or, if the size of the array is odd, then it is the boilerplate of the two middle values.

\[Med(Ten) = \begin{cases} X_{s} \begin{bmatrix} \frac{n}{2}\\ \end{bmatrix} & \text{if due north is fifty-fifty}\\ \frac{(X_{due south}\begin{bmatrix} \frac{n-ane}{2}\\ \end{bmatrix} + \begin{bmatrix} \frac{north+1}{2}\\ \stop{bmatrix})}{ii} & \text{if northward is odd} \terminate{cases}\]

Note: The array $10$ must be sorted (indicated by the 's' subscript in $X_s$). The brackets in the equation above point indices, like to arrays in programming.

But how can nosotros obtain this "middle" value efficiently? We know that re-sorting an array on each value insert tin exist computationally expensive. Thus, typically realtime median filters use other information structures, similar indexable skiplists, to efficiently proceed a sorted data structure on inserts and removals.

Like to the moving boilerplate filter, we can tweak the moving median filter's performance by modifying the filter window size. Below, we show a moving median filter with window sizes 5, 11, and 21. For this video, we used our exam code MovingMedianFilterWindowSizeDemo.ino, which relies on Luis Llama's Arduino Median Filter two library based on Phil Ekstrom's "Better Than Boilerplate" article.

Video This video shows moving median filter operation with window sizes 5, eleven, and 21. Discover how a median filter tends to flatten "peaks" in the signal, which is unlike the other filters we've examined. To make this video, we used this code and the congenital-in Arduino Serial Plotter.

Why use a median filter?

Median filters are widely used in image processing to remove noise from images (image processing is its own subfield of bespeak processing focusing on 2D DSP techniques). Unlike mean (or average) filters, median filters remove noise while preserving edges—and edges are often a crucial part of other paradigm processing algorithms like the Canny edge detector.

Effigy. Median filtering is widely used in image processing where it is particularly effective at removing "speckle" or "salt-and-pepper" dissonance while preserving edges. Image from Wikipedia.

In the example of 1-dimensional signal processing, which we've focused on in this lesson, median filters take the aforementioned advantage: they provide a smoothing technique the preserves edges in our signal. For example, what if our data is from an underlying clock bespeak that should accept sharp ascension and falling edges, which we don't wish to smooth. A moving average filter distorts rise and fall times while the median filter sharpens them.

Figure. Images from MathWorks.

Other filters

In this lesson, nosotros covered simply a few basic digital filters merely many others be—some which permit you to really command which frequencies in your signal to eliminate. For example, high-pass filters can remove specific low-frequency components from your point while keeping high frequencies, low-pass filters eliminate high-frequency components while keeping depression frequencies, bandpass filters let y'all specify a range (or ring) of frequencies to keep, etc.

Other popular filters include the Savitzky-Golay filter, the Butterworth filter, and the Kalman filter. The Savitzky-Golay filter, for case, is like a weighted moving average filter that attempts to fit a polynomial over the sliding window (to improve fit the underlying signal)—see this MathWorks article.

In full general, it is not helpful or appropriate to perform filtering investigations in real-time on sensor information because it'south difficult to replicate input signals and test and compare filtering algorithms. Yes, information technology's fine to experiment with filters+real-time information for gut checking or to get something working quickly merely non for more than deep signal assay.

Thus, if you're interested in this expanse, we suggest experimenting with the filters in SciPy with Jupyter Notebook. Y'all should log the sensor information to your computer and and then clarify information technology "offline" in a testbed environment, as we exercise in our Step Tracker and Gesture Recognition assignments. This will allow you to experiment with and compare different algorithm approaches and parameter tuning.

Activeness

For your prototyping activeness, we would like you to choose a sensor from your hardware kits—it could be a potentiometer, a hall effect sensor, a force-sensitive resistor, a photoresistor, an accelerometer, a DIY sensor, etc.—and two different smoothing algorithms to apply to it.

More specifically, build an appropriate excursion for your sensor, read the input on an analog input pin, process this input with two dissimilar smoothing algorithms (either those we covered in this lesson or across), graph the iii signals (raw signal, smoothing algorithm ane output, smoothing algorithm 2 output), record a video of your input + the graphs, and report on your observations in the prototyping journal. Include a link to your video (or an embedded animated gif).

Arduino filtering libraries

There are lots of Arduino filtering libraries online and general C++ filtering lawmaking that could be adjusted to the Arduino context. The usual disclaimers utilise: we have non had a chance to evaluate all of these libraries. And then, utilise at your ain chance. :)

Kick Filter Library, by LinnesLab on GitHub. Here's the associated IEEE publication from Linnes Lab's Boot LL smartwatch, a research device for measuring heart rate, respiration, and claret oxygen, which was the impetus for creating the library.
Arduino Filters, past tttapa on GitHub
Microsmooth, past asheeshr on GitHub
Median Filter Library 2, by Luis Llamas based on an article by Phil Ekstrom
Moving Boilerplate Filter past the Makeability Lab

Resource

Signal Smoothing, Mathworks.com
Arduino Elementary High-pass, Ring-pass, and Band-terminate Filtering, Norwegian Creations
Sensor Filters for Coders, Hackaday
Moving Average, Wikipedia
Exponential Moving Average, Pieter P

rogerswittleen1945.blogspot.com

Source: https://makeabilitylab.github.io/physcomp/advancedio/smoothing-input.html

Rogers Wittleen1945