digital filter

Try executing, at some interval,

filtered = (filtered + newsample) / 2.

I like having a time constant: filtered = (0.9 * filtered + 0.1 * newsample)

Play around with it, it's not hard to get useful filtering.

Kelly

A very slight modification of this may be useful in some cases:

The equation above is in the form:

filtered = (1-k) * filtered + k * newsample

This can be written:

filtered = filtered + k * (newsample - filtered)

Mathematically, these are identical. The second one does have some practical advantages, though:

1. with small k (long decay time) and limited calculation precision the round-off errors are smaller
2. with non-constant k there is no need for 1-k

Computationally, the relative cost of these two ways depends on the relative cost of multiplication and addition (2 mult/1 add vs. 1 mult/2 add).

- Ville

I believe this is the one I remember:

I picked k to be a power of 2 so that a shift instruction could be used for speed. I try these out.

Thanks to all! Doug

Yes, it's under "advanced search" on this webpage:

-----

Hummm. That's where I looked first. I try again.

Doug

to a

single

it

Here, and this includes my contribution to the thread:

Best regards, Spehro Pefhany

That's the one! Thanks!

Doug

Here is the very simplest digital lowpass:

Y += (X-Y)*k

X = input, Y = output

Here is how k is defined:

k = 1 - exp(-Fc/Fdis))

where Fc = cutoff frequency, Fdis = sample rate

Vladimir Vassilevsky

DSP and Mixed Signal Design Consultant

Doug Dots>

Right! I picked n to be a power of 2 (8 actually in my application) and in C it turns into:

y += (x - y) >> n;

Works great!

Doug

to a

single

Used it

I presume you mean "y += (x - y) >> p;" where "p" is the power rather than n (e.g., 3 rather than 8).

But beware...

On your platform. This revision.

There are no guarantees that right shifting a signed value will yield the result you desire. You might get zeros shifted in regardless of the actual sign of the value being shifted.

Most compilers are smart enough to make the "shift to divide by a power of two" optimization on their own. The following

y += (x - y) / n;

will be guaranteed to work, and should produce nearly identical code on your system.

Regards,

-=Dave

If it doesn't, and the speed turns out to be critical, he could use unsigned ints and a bias, such as INT_MAX. The input y would have to first be corrected to INT_MAX + yin, where yin is int and y is unsigned. The filtered y would need to be initialized to INT_MAX also. This assumes that INT_MAX is roughly 1/2 of UINT_MAX.

So the result would be, more or less:

#include

unsigned int avg = INT_MAX; unsigned int sig; int input;

#define FACTOR 3

....

sig = (unsigned)input + INT_MAX) avg += (sig - avg) >> FACTOR;

which also avoids triggering UB via integer overflows.

Oops! You ae correct.

I didn't include all the contect of my application. 12 bit positive values,

Doug