Led bar indicator flickering within adjacent values and how to avoid this (embedded-C)

Question

I am designing a measurement instrument that has a visible user output on a 30-LEDs bar. The program logic acts in this fashion (pseudo-code)

while(1)
{
 (1)Sensor_Read();
 (2)Transform_counts_into_leds();
 (3)Send_to_bar();
{

The relevant function (2) is a simple algorithm that transforms the counts from the I2C sensor to a value serially sent to shift-registers that control the single leds. The variable sent to function (3) is simply the number of LEDs that have to stay on (0 for al LEDs off, 30 for all LEDs on)

uint8_t Transform_counts_into_leds(uint16_t counts)
{
 float on_leds;
 on_leds = (uint8_t)(counts * 0.134);    /*0.134 is a dummy value*/
 return on_leds;
}

using this program logic when counts value is on the threshold between two LEDs, the next led flickers

I think this is a bad user experience for my device and I want the LEDs, once lit, to stay stable in a small range of values.

QUESTION: How a solution to this problem could be implemented in my project?

Answer 1

Hysteresis is useful for a number of applications, but I would suggest not appropriate in this instance. The problem is that if the level genuinely falls from say 8 to 7 for example you would not see any change until at least one sample at 6 and it would jump to 6 and there would have to be a sample of 8 before it went back to 7.

A more appropriate solution in the case is a moving average, although it is simpler and more useful to use a moving sum and use the higher resolution that gives. For example a moving-sum of 16 effectively adds (almost) 4 bits of resolution, making a 8 bit sensor effectively 12 bit - at the cost of bandwidth of course; you don't get something for nothing. In this case lower bandwidth (i.e. less responsive to higher frequencies is exactly what you need)

Moving sum:

#define BUFFER_LEN 16 ;
#define SUM_MAX (255 * BUFFER_LEN)
#define LED_MAX 30

uint8_t buffer[BUFFER_LEN] = {0} ;
int index = 0 ;
uint16_t sum = 0 ;

for(;;)
{
    uint8_t sample = Sensor_Read() ;

    // Maintain sum of buffered values by 
    // subtracting oldest buffered value and 
    // adding the new sample
    sum -= buffer[index] ;              
    sum += sample ;

    // Replace oldest sample with new sample 
    // and increment index to next oldest sample
    buffer[index] = sample ;
    index = (index + 1) % BUFFER_LEN ;

    // Transform to LED bar level
    int led_level = (LED_MAX * sum) / SUM_MAX ;

    // Show level
    setLedBar( led_level ) ;
}

Answer 2

The underlying problem -- displaying sensor data in a human-friendly way -- is very interesting. Here's my approach in pseudocode:

Loop:

    Read sensor
    If sensor outside valid range:
        Enable warning LED
        Sleep in a low-power state for a while
        Restart loop            
    Else:
        Disable warning LED

    Filter sensor value

    Compute display value from sensor value with extra precision:
        If new display value differs sufficiently from current value:
            Update current displayed value

    Update display with scaled-down display value

Filtering deals with noise in the measurements. Filtering smoothes out any sudden changes in the measurement, removing sudden spikes. It is like erosion, turning sharp and jagged mountains into rolling fells and hills.

Hysteresis hides small changes, but does not otherwise filter the results. Hysteresis won't affect noisy or jagged data, it only hides small changes.

Thus, the two are separate, but complementary methods, that affect the readout in different ways.

Below, I shall describe two different filters, and two variants of simple hysteresis implementation suitable for numeric and bar graph displays.

If possible, I'd recommend you write some scripts or test programs that output the input data and the variously filtered output data, and plot it in your favourite plotting program (mine is Gnuplot). Or, better yet, experiment! Nothing beats practical experiments for human interface stuff (at least if you use existing suggestions and known theory as your basis, and leap forward from there).

---

Moving average:

You create an array of N sensor readings, updating them in a round-robin fashion, and using their average as the current reading. This produces very nice (as in human-friendly, intuitive) results, as only the N latest sensor readings affect the average.

When the application is first started, you should copy the very first reading into all N entries in the averaging array. For example:

#define  SENSOR_READINGS  32

int sensor_reading[SENSOR_READINGS];
int sensor_reading_index;

void sensor_init(const int reading)
{
    int i;

    for (i = 0; i < SENSOR_READINGS; i++)
        sensor_reading[i] = reading;

    sensor_reading_index = 0;
}

int sensor_update(const int reading)
{
    int i, sum;

    sensor_reading_index = (sensor_reading_index + 1) % SENSOR_READINGS;
    sensor_reading[sensor_reading_index] = reading;

    sum = sensor_reading[0];
    for (i = 1; i < SENSOR_READINGS; i++)
        sum += sensor_reading[i];

    return sum / SENSOR_READINGS;
}

At start-up, you call sensor_init() with the very first valid sensor reading, and sensor_update() with the following sensor readings. The sensor_update() will return the filtered result.

The above works best when the sensor is regularly polled, and SENSOR_READINGS can be chosen large enough to properly filter out any unwanted noise in the sensor readings. Of course, the array requires RAM, which may be on short supply in some microcontrollers.

---

Exponential smoothing:

When there is not enough RAM to use a moving average to filter data, an exponential smoothing filter is often applied.

The idea is that we keep an average value, and recalculate the average using each new sensor reading using (A * average + B * reading) / (A + B). The effect of each sensor reading on the average decays exponentially: the weight of the most current sensor reading is always B/(A+B), the weight of the previous one is A*B/(A+B)^2, the weight of the one before that is A^2*B/(A+B)^3, and so on (^ indicating exponentiation); the weight of the n'th sensor reading in the past (with current one being n=0) is A^n*B/(A+B)^(n+1).

The code corresponding to the previous filter is now

#define SENSOR_AVERAGE_WEIGHT 31
#define SENSOR_CURRENT_WEIGHT  1

int sensor_reading;

void sensor_init(const int reading)
{
    sensor_reading = reading;
}

int sensor_update(const int reading)
    return sensor_reading = (sensor_reading * SENSOR_AVERAGE_WEIGHT +
                             reading * SENSOR_CURRENT_WEIGHT) /
                            (SENSOR_AVERAGE_WEIGHT + SENSOR_CURRENT_WEIGHT);
}

Note that if you choose the weights so that their sum is a power of two, most compilers optimize the division into a simple bit shift.

---

Applying hysteresis:

(This section, including example code, edited on 2016-12-22 for clarity.)

Proper hysteresis support involves having the displayed value in higher precision than is used for output. Otherwise, your output value with hysteresis applied will never change by a single unit, which I would consider a bad design in an user interface. (I'd much prefer a value to flicker between two consecutive values every few seconds, to be honest -- and that's what I see in e.g. the weather stations I like best with good temperature sensors.)

There are two typical variants in how hysteresis is applied to readouts: fixed, and dynamic. Fixed hysteresis means that the displayed value is updated whenever the value differs by a fixed limit; dynamic means the limits are set dynamically. (The dynamic hysteresis is much rarer, but it may be very useful when coupled with the moving average; one can use the standard deviation (or error bars) to set the hysteresis limits, or set asymmetric limits depending on whether the new value is smaller or greater than the previous one.)

The fixed hysteresis is very simple to implement. First, because we need to apply the hysteresis to a higher-precision value than the output, we choose a suitable multiplier. That is, display_value = value / DISPLAY_MULTIPLIER, where value is the possibly filtered sensor value, and display_value is the integer value displayed (number of bars lit, for example).

Note that below, display_value and the value returned by the functions, refer to the integer value displayed, for example the number of lit LED bars. value is the (possibly filtered) sensor reading, and saved_value containing the sensor reading that is currently displayed.

#define DISPLAY_HYSTERESIS 10
#define DISPLAY_MULTIPLIER 32

int saved_value;

void display_init(const int value)
{
    saved_value = value;
}

int display_update(const int value)
{
    const int delta = value - saved_value;
    if (delta < -DISPLAY_HYSTERESIS ||
        delta >  DISPLAY_HYSTERESIS)
        saved_value = value;
    return saved_value / DISPLAY_MULTIPLIER;
}

The delta is just the difference between the new sensor value, and the sensor value corresponding to the currently displayed value.

The effective hysteresis, in units of displayed value, is DISPLAY_HYSTERESIS/DISPLAY_MULTIPLIER = 10/32 = 0.3125 here. It means that the displayed value can be updated three times before a visible change is seen (if e.g. slowly decreasing or increasing; more if the value is just fluctuating, of course). This eliminates rapid flickering between two visible values (when the value is in the middle of two displayed values), but ensures the error of the reading is less than half display units (on average; half plus effective hysteresis in the worst case).

In a real life application, you usually use a more complete form return (saved_value * DISPLAY_SCALE + DISPLAY_OFFSET) / DISPLAY_MULTIPLIER, which scales the filtered sensor value by DISPLAY_SCALE/DISPLAY_MULTIPLIER and moves the zero point by DISPLAY_OFFSET/DISPLAY_MULTIPLIER, both evaluated at 1.0/DISPLAY_MULTIPLIER precision, but only using integer operations. However, for simplicity, I'll just assume that to derive the display value value, say the number of lit LED bars, you just divide the sensor value by DISPLAY_MULTIPLIER. In either case, the hysteresis is DISPLAY_HYSTERESIS/DISPLAY_MULTIPLIER of the output unit. Ratios of about 0.1 to 0.5 work fine; and the below test values, 10 and 32, yields 0.3125, which is about midway of the range of ratios that I believe work best.

Dynamic hysteresis is very similar to above:

#define DISPLAY_MULTIPLIER 32

int saved_value_below;
int saved_value;
int saved_value_above;

void display_init(const int value, const int below, const int above)
{
    saved_value_below = below;
    saved_value = value;
    saved_value_above = above;
}

int display_update(const int value, const int below, const int above)
{
    if (value < saved_value - saved_value_below ||
        value > saved_value + saved_value_above) {
        saved_value_below = below;
        saved_value = value;
        saved_value_above = above;
    }
    return saved_value / DISPLAY_MULTIPLIER;
}

Note that if DISPLAY_HYSTERESIS*2 <= DISPLAY_MULTIPLIER, the displayed value is always within a display unit of the actual (filtered) sensor value. In other words, hysteresis can easily deal with flickering, but it does not need to add much error to the displayed value.

In many practical cases the best amount of hysteresis applied depends on the amount of short-term variations in the sensor samples. This includes not only noise, but also the types of signals that are to be measured. A hysteresis of just 0.3 (relative to the output unit) is sufficient to completely eliminate the flicker when sensor readings flip the filtered sensor value between two consecutive integers that map to different integer ouputs, as it ensures that the filtered sensor value must change by at least 0.3 (in output display units) before it effects a change in the display.

The maximum error with hysteresis is half display units plus the current hysteresis. The half unit is the minimum error possible (since consecutive units are one unit apart, so when the true value is in the middle, either value shown is correct to within half a unit). With dynamic hysteresis, if you always start with some fixed hysteresis value when a reading changes enough, but when the reading is within the hysteresis, you instead just decrease the hysteresis (if greater than zero). This approach leads to a changing sensor value being tracked correctly (maximum error being half an unit plus the initial hysteresis), but a relatively static value being displayed as accurately as possible (at half an unit maximum error). I don't show an example of this, because it adds another tunable (how the hysteresis decays towards zero), and requires that you verify (calibrate) the sensor (including any filtering) first; otherwise it's like polishing a turd: possible, but not useful.

Also note that if you have 30 bars in the display, you actually have 31 states (zero bars, one bar, .., 30 bars), and thus the proper range for the value is 0 to 31*DISPLAY_MULTIPLIER - 1, inclusive.