CODEWITHSUNDEEP
carrays
Doug G.
Doug G.

Reputation: 51

Implementing a running average using a circular buffer array

I'm trying to implement a circular buffer in order to average a stream of data points generated by a pressure sensor in C running on an embedded controller. The idea is to store the last N pressure readings in the buffer while maintaining a running sum of the buffer. Average = sum / N. Should be trivial.

However, the average I'm seeing is a value that starts near the pressure reading (I preload the buffer registers with a typical value), but which subsequently trends towards zero. If I also display the sum, it too is dropping asymptotically to zero. If the pressure changes, the average moves away from zero in the direction of the pressure change, but returns to its zero trend as soon as the pressure stabilizes.

If anyone could spot the error I'm making, it would be very helpful.

    #define ARRAYSIZE 100

    double Sum;                       // variable for running sum
    double Average;                   // variable for average
    double PressureValue[ARRAYSIZE];  // declare value array
    int i;                            // data array index

    int main(void) {

      while (1) 
      {
        if (i == ARRAYSIZE) i = 0;       // test index, reset if it reaches the upper boundary
        Sum = Sum - PressureValue[i];    // subtract the old datapoint from running sum
        PressureValue[i] = PRESSURE;     // replace previous loop datapoint with new data
        Sum = Sum + PressureValue[i];    // add back the new current value to the running sum
        Average = Sum / ARRAYSIZE;       // calculate average value = SUM / ARRAYSIZE
        ++i;                             // increment index
      }                                  // end while loop

    }                                    // end main

The averaging code takes place in an interrupt handler; I'm reading the data from the pressure sensor via I2C with interrupts triggered at the end of each I2C communication phase. During the last phase, after the four bytes comprising the pressure data have been retrieved, they are assembled into a complete reading, and then converted to a decimal reading in PSI contained in the PRESSURE variable.

Obviously , this isn't a direct cut and paste from my code, but I didn't want anyone to have to wade through the whole thing, so I've limited it to just the stuff relevant to figuring the average, and changed the variable names to be more readable. Still, I can't spot what I'm doing wrong.

Thanks for your attention!

Doug G.

Upvotes: 5

Views: 7780

Answers (2)

MattGreenleaf
MattGreenleaf

Reputation: 1

It is also possible your code is working exactly as intended. If you are preloading your array with typical values outside of this loop and then running this code you would get the behavior you are describing. If you are preloading the array make sure you are preloading the sum and average otherwise you are essentially measuring gauge pressure with you preloaded value as atmospheric pressure.

Upvotes: 0

Crowman
Crowman

Reputation: 25926

I don't see anything obviously wrong with your code, but as you say, you're not providing all of it, so who knows what's happening in the rest of it (in particular, how/if you're initializing i and Sum), but the following works fine for me, which is basically the same algorithm you have:

#include <stdio.h>
#include <stddef.h>

double PressureValue[8];
double Pressures[800];

int main(void) {
    const size_t array_size = sizeof(PressureValue) / sizeof(PressureValue[0]);
    const size_t num_pressures = sizeof(Pressures) / sizeof(Pressures[0]);
    size_t count = 0, i = 0;
    double average = 0;


    /*  Initialize PressureValue to {0, 1, 2, 3, ...}  */

    for ( size_t n = 0; n < array_size; ++n ) {
        PressureValue[n] = n;
    }
    double sum = ((array_size - 1) / (double) 2) * array_size;

    /*  Initialize pressures to repeats of PressureValue  */

    for ( size_t n = 0; n < num_pressures; ++n ) {
        Pressures[n] = n % array_size;
    }

    while ( count < num_pressures ) {
        if ( i == array_size )
            i = 0;
        sum -= PressureValue[i];
        PressureValue[i] = Pressures[count++];
        sum += PressureValue[i++];
    }

    average = sum / array_size;

    printf("Sum is %f\n", sum);
    printf("Counted %zu pressures\n", count);
    printf("Average is %f\n", average);

    return 0;
}

Outputs:

paul@local:~/src/c/scratch$ ./pressure
Sum is 28.000000
Counted 800 pressures
Average is 3.500000
paul@local:~/src/c/scratch$

Just one more possibility, when you say they are "converted to a decimal reading in PSI contained in the PRESSURE variable", and elsewhere, for that matter, make sure you're not getting things truncated to zero because of integer division. If you've got things "trending to zero" as you're adding more, that's something I'd be immediately suspicious of. A classic error in converting Fahrenheit to Celsius, for instance, would be to write c = (f - 32) * (5 / 9), where that (5 / 9) truncates to zero every time, and always leaves you with c == 0.

Also, as a general rule, I understand that you "didn't want anyone to have to wade through the whole thing", but you'd be surprised how many times the real problem is not in the part of the code that you think it is. This is why it's important to provide an SSCCE to ensure that you can narrow down your code and actually isolate and reproduce the problem. If you try to narrow down your code and find that you can't isolate and reproduce the problem, then it's almost certain that your issue is not being caused by the thing you think is causing it.

Upvotes: 3

Related Questions