Originally Posted by

**Rezo**
I will have to sample the data twice in each loop, correct?

No, just once (gauge_value).

Think of gauge_shown as the needle in the gauge, dragged around by the sampled gauge_value , but limited to a maximum rate of change.

If the sampled value jitters, and you want to smooth that out, you'll need to instead implement a smoothing filter.

The two most commonly used filtering schemes for this sort of stuff are *exponential* and *windowed*.

Exponential is the simplest, but may take some experimentation to find the optimum coefficient. The code itself is trivial:

Code:

#define GAUGE_COEFFICIENT 0.75 /* between 0.5 and 1 */
gauge_shown = GAUGE_COEFFICIENT * gauge_value + (1.0f - GAUGE_COEFFICIENT) * gauge_shown;

This is called *exponential* (often exponential smoothing) because the shown value is essentially a mix of samples thus far, with exponentially decaying weights.

The optimum GAUGE_COEFFICIENT depends on the amount of jitter, and how rapidly the shown gauge should react to large changes. The smaller, the smoother; the closer to one, the faster it reacts.

Windowed filtering involves keeping a short queue of sampled values, always replacing the oldest one with the new sample, and showing their average:

Code:

#define GAUGE_SAMPLES 20
float gauge_sample[GAUGE_SAMPLES];
unsigned int gauge_sample_index = 0;
int i;
/* Add a new sample */
gauge_sample[gauge_sample_index++] = gauge_value;
if (gauge_sample_index >= GAUGE_SAMPLES)
gauge_sample_index = 0;
/* Calculate average */
gauge_shown = 0.0f;
for (i = 0; i < GAUGE_SAMPLES; i++)
gauge_shown += gauge_sample[i];
gauge_shown /= GAUGE_SAMPLES;

The optimum window size (GAUGE_SAMPLES) depends on the jitter in gauge_value samples.

The window size also determines the amount of latency (delay in registering a change) the shown gauge has.

For example, if the samples are first all zeroes, and then suddenly change to one, it takes GAUGE_SAMPLES updates before the shown gauge gets to one. It will rise there linearly.

Sometimes the window is also weighted, but I would guess that in this kind of application the exponential filter will work better (than a weighted windowing filter).