Low pass filter on ongoing samples.

[JKhal]

Hi all,

My application requires to sample a sensor and send the samples out in real time, without saving the samples.

I am required to run a low pass filter on the samples, but here is the problem cause if I want to do it on 20 samples for example then I will not be able to send out the samples each after I got it as required, and when I send them immediately each after I got it I use an ongoing average on 10 samples but that wasn't enough.

what low pass filter algorithm is the best for this application?

what is the accepted way to do this ?

Best regards

JK

[JElli.1]

Try the Exponential, or First-order filter:

Y[n] = dY[n-1] + (1-d)X[n]

·              Y[n] is the current output

·              Y[n-1] is the previous output

·              X[n] is the current input

·              d is the damping factor

The damping factor is a number between 0 and 1. If d = 0, the output is just equal to the input, and no filtering (smoothing) takes place.

The closer d is to 1, the greater the amount of filtering (smoothing).

  

Here is an example:

The input signal is a Sine function with amplitude +- 100, added to that is random noise of +-10.

To filter out the noise we run the data through the filter equation first with d = 0.5 and then d = 0.8

 

 Code to reproduce the above >>

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "math.h"
#include "stdlib.h"
 
// ......
 
/* USER CODE BEGIN PV */
int R;
float d, Xin, Yout, Yprev, X[37], Y[37];
float e, f, g;
 
 
// ......
 
 /* USER CODE BEGIN 2 */
 
 // FIRST ORDER DIGITAL FILTER
 d = 0.5; // Damping factor (adjust as needed)
 srand(123);
 R = (rand() % 20) - 10; // random number from -10 to +10
 Xin = 100*sin(0) + R; // Input 0 (Sine function with noise)
 Yprev = Xin; // Initial value for previous output
 X[0] = Xin; // for plotting only
 Y[0] = Xin; // for plotting only
 
 for (int n = 1; n < 37; n++) // This will be a "while (1)"- infinite loop in final project
 {
 	R = (rand() % 20) - 10; // random number from -10 to +10
 	Xin = 100*sin(n*M_PI/18) + R; // Input n (Sine function with noise)
 	Yout = d*Yprev + (1-d)*Xin; // Output n (Filtered)
 	Yprev = Yout; // Save previous output
 
 	X[n] = Xin; // saving data in arrays just for plotting the ..
 	Y[n] = Yout; // graph afterwards (not needed in final project)
 }
 

If you need stronger filtering, you can go to a second or even third order digital filter:

Second-order:

Y[n] = eY[n-1] + fY[n-2] + (1-e-f)X[n]

 

·              e = 2*d   (where d is the damping factor as before)

·              f = -d*d

 

 Third-order:

Y[n] = eY[n-1] + fY[n-2] + gY[n-3] + (1-e-f-g)X[n]

 

·              e = 3*d   (where d is the damping factor as before)

·              f = -3*d*d

·              g = d*d*d

Add the following code, below the previous, to try the second and third order filters.

We just use the data already in the X[n] array as input to generate a new Y[n] output array. >>

// SECOND ORDER DIGITAL FILTER
 d = 0.5; // Damping factor (adjust as needed)
 e = 2*d;
 f = -d*d;
 Y[0] = X[0];
 Y[1] = X[0];
 
 for (int n = 2; n < 37; n++)
 {
 	Y[n] = e*Y[n-1] + f*Y[n-2] + (1-e-f)*X[n];
 }
 
 // THIRD ORDER DIGITAL FILTER
 d = 0.5; // Damping factor (adjust as needed)
 e = 3*d;
 f = -3*d*d;
 g = d*d*d;
 Y[0] = X[0];
 Y[1] = X[0];
 Y[2] = X[0];
 
 for (int n = 3; n < 37; n++)
 {
 Y[n] = e*Y[n-1] + f*Y[n-2] + g*Y[n-3] + (1-e-f-g)*X[n];
 }
 

Here is a real world example:

Noisy pressure sensor – data; filtered with first order and third order filter, both with d=0.8