Question

I have an app that accepts integers at a variable rate every .25 to 2 seconds.

I’d like to output the data in a smoothed format for 3, 5 or 7 seconds depending on user input.

If the data always came in at the same rate, let’s say every .25 seconds, then this would be easy. The variable rate is what confuses me.

Data might come in like this:
Time – Data
0.25 – 100
0.50 – 102
1.00 – 110
1.25 – 108
2.25 – 107
2.50 – 102
ect…

I’d like to display a 3 second rolling average every .25 seconds on my display.

The simplest form of doing this is to put each item into an array with a time stamp.

array.push([0.25, 100])  
array.push([0.50, 102])  
array.push([1.00, 110])  
array.push([1.25, 108])  

ect…

Then every .25 seconds I would read through the array, back to front, until I got to a time that was less than now() - rollingAverageTime. I would sum that and display it. I would then .Shift() the beginning of the array.

That seems not very efficient though. I was wondering if someone had a better way to do this.

Answer 1

Why don’t you save the timestamp of the starting value and then accumulate the values and the number of samples until you get a timestamp that is >= startingTime + rollingAverageTime and then divide the accumulator by the number of samples taken?

EDIT:
If you want to preserve the number of samples, you can do this way:

Take the accumulator, and for each input value sum it and store the value and the timestamp in a shift register; at every cycle, you have to compare the latest sample’s timestamp with the oldest timestamp in the shift register plus the smoothing time; if it’s equal or more, subtract the oldest saved value from the accumulator, delete that entry from the shift register and output the accumulator, divided by the smoothing time. If you iterate you obtain a rolling average with (i think) the least amount of computation for each cycle:

• a sum (to increment the accumulator)
• a sum and a subtraction (to compare the timestamp)
• a subtraction (from the accumulator)
• a division (to calculate the average, done in a smart way can be a shift right)

For a total of about 4 algebric sums and a division (or shift)

EDIT:

For taking into account the time from the last sample as a weighting factor, you can divide the value for the ratio between this time and the averaging time, and you obtain an already weighted average, without having to divide the accumulator.

I added this part because it doesn’t add computational load, so you can implement quite easy if you want to.