smoothing an analog input for a seven seg display

Projects Programming
1

Hello,

I am working on some gauges for my car. So far i have boost pressure, fuel pressure, oil pressure, and an idiot light system to let me know something is wrong.

The gauges work but they are jittery. I tried a rough smoothing on the oil pressure values and it seems to not be working. the code is really long but here it is.

the jist is three analog reads from three 0-5 volt sensors and each sensor runs a three digit seven seg dispay and they are registering accurate but to fast to read. How can i smooth the analog inputs.

thank you .
p.s. i know the code is sloppy this is a first attempt to get the gauges working.

2 
//oil pressure
int oilA = 31;
int oilB = 26;
int oilC = 29;
int oilD = 30;
int oilE = 28;
int oilF = 24;
int oilG = 27;
int oGround1 = 22;
int oGround2 = 23;
const int oilReadings =10;
int readingso[oilReadings];
int readIndexo = 0;
int totalo = 0;
int averageo = 0;
//end oil pressure

 //oil pressure setup
pinMode(oilA, OUTPUT);
pinMode(oilB, OUTPUT);
pinMode(oilC, OUTPUT);
pinMode(oilD, OUTPUT);
pinMode(oilE, OUTPUT);
pinMode(oilF, OUTPUT);
pinMode(oilG, OUTPUT);
pinMode(oGround1, OUTPUT);
pinMode(oGround2, OUTPUT);
for (int thisReading = 0 ; thisReading < oilReadings; thisReading ++) 
readingso[thisReading] = 0;
//end oil pressure
//oil pressure code'

 int oilpressure = analogRead(A2);
totalo = totalo - readingso[readIndexo];
readingso[readIndexo] = analogRead(oilpressure);
totalo = totalo + readingso[readIndexo];
readIndexo = readIndexo + 1; 
if (readIndexo >= oilReadings)
readIndexo = 0;
averageo = totalo / oilReadings;
Serial.println(averageo);
  
if (oilpressure >= 0 && oilpressure < 10)
ozero();
else  if (oilpressure >= 10 && oilpressure < 20)
oone();
else  if (oilpressure >= 20 && oilpressure < 31)
otwo();
else  if (oilpressure >= 31 && oilpressure < 41)
othree();
else  if (oilpressure >= 41 && oilpressure < 52)
ofour();
else  if (oilpressure >= 52 && oilpressure < 62)
ofive();
else  if (oilpressure >= 62 && oilpressure < 73)
osix();
else  if (oilpressure >= 73 && oilpressure < 83)
oseven();
else  if (oilpressure >= 83 && oilpressure < 93)
oeight();
else  if (oilpressure >= 93 && oilpressure < 104)
onine();
else  if (oilpressure >= 104 && oilpressure < 114)
{ oten();
    ozero();
  }
  else   if (oilpressure >= 114 && oilpressure < 125)
  { oten();
    oone();
  }
  else   if (oilpressure >= 125 && oilpressure < 135)
  { oten();
    otwo();
  }
  else  if (oilpressure >= 135 && oilpressure < 146)
  { oten();
    othree();
  }
  else   if (oilpressure >= 146 && oilpressure < 156)
  { oten();
    ofour();
  }
  else  if (oilpressure >= 156 && oilpressure < 167)
  { oten();
    ofive();
  }
  else  if (oilpressure >= 167 && oilpressure < 177)
  { oten();
    osix();
  }
  else   if (oilpressure >= 177 && oilpressure < 187)
  { oten();
    oseven();
  }
  else  if (oilpressure >= 187 && oilpressure < 198)
  { oten();
    oeight();
  }
  else   if (oilpressure >= 198 && oilpressure < 208)
  { oten();
    onine();
  }
  else  if (oilpressure >= 208 && oilpressure < 219)
  { otwenty();
    ozero();
  }
  else  if (oilpressure >= 219 && oilpressure < 229)
  { otwenty();
    oone();
  }
  else  if (oilpressure >= 229 && oilpressure < 240)
  { otwenty();
    otwo();
  }
  else  if (oilpressure >= 240 && oilpressure < 250)
  { otwenty();
    othree();
  }
  else   if (oilpressure >= 250 && oilpressure < 260)
  { otwenty();
    ofour();
  }
  else  if (oilpressure >= 260 && oilpressure < 271)
  { otwenty();
    ofive();
  }
  else  if (oilpressure >= 271 && oilpressure < 281)
  { otwenty();
    osix();
  }
  else  if (oilpressure >= 281 && oilpressure < 292)
  { otwenty();
    oseven();
  }
  else   if (oilpressure >= 292 && oilpressure < 302)
  { otwenty();
    oeight();
  }
  else   if (oilpressure >= 302 && oilpressure < 313)
  { otwenty();
    onine();
  }
  else  if (oilpressure >= 313 && oilpressure < 323)
  { othirty();
    ozero();
  }
  else  if (oilpressure >= 323 && oilpressure < 334)
  { othirty();
    oone();
  }
  else   if (oilpressure >= 334 && oilpressure < 344)
  { othirty();
    otwo();
  }
  else   if (oilpressure >= 344 && oilpressure < 354)
  { othirty();
    othree();
  }
  else   if (oilpressure >= 354 && oilpressure < 365)
  { othirty();
    ofour();
  }
  else   if (oilpressure >= 365 && oilpressure < 375)
  { othirty();
    ofive();
  }
  else   if (oilpressure >= 375 && oilpressure < 386)
  { othirty();
    osix();
  }
  else   if (oilpressure >= 386 && oilpressure < 396)
  { othirty();
    oseven();
  }
  else   if (oilpressure >= 396 && oilpressure < 407)
  { othirty();
    oeight();
  }
  else   if (oilpressure >= 407 && oilpressure < 417)
  { othirty();
    onine();
  }
  else  if (oilpressure >= 417 && oilpressure < 427)
  { ofourty();
    ozero();
  }
  else   if (oilpressure >= 427 && oilpressure < 438)
  { ofourty();
    oone();
  }
  else   if (oilpressure >= 438 && oilpressure < 448)
  { ofourty();
    otwo();
  }
  else   if (oilpressure >= 448 && oilpressure < 459)
  { ofourty();
    othree();
  }
  else   if (oilpressure >= 459 && oilpressure < 469)
  { ofourty();
    ofour();
  }
  else  if (oilpressure >= 469 && oilpressure < 480)
  { ofourty();
    ofive();
  }
  else  if (oilpressure >= 480 && oilpressure < 490)
  { ofourty();
    osix();
  }
  else   if (oilpressure >= 490 && oilpressure < 501)
  { ofourty();
    oseven();
  }

    }
delay(5);
}
3

i cut most of the code out and halfd the code for the oil pressure but it gives the rough idea.

4

Create an array that has, say 8 values in it.
Have an integer index into the array.
Initialize the array with the first value in each
location total the values in the array and save
this to a variable.
For the loop part:
Divide that variable by 8 to display.
Each time you read a new value, use the index
to fetch the value there first and subtract it from
the variable. Store the new value at the point and
add it to the variable.
Now increment the pointer and AND it with 0x0F
( for 8 elements ). Loop back.

You then have created a filter. Of sorts. Each input
has a sensitivity of only 1/8 of what is was.
You can make a more complicated filter that scales
each value, depending on how long it was in the filter.
That way you can make newer values have more
more than 1/8 and older values less. This improves
response.
These type filters are called FIR or finite input response.
There is another type called IIR for infinite input response.
Both type are useful but have different problems with
sampled system. Both can be made to have faster response
but along with faster response is more jitter or jumping
around.
You should also have some analog input filtering such that any
input response is some less than 1/2 the sampling frequency
or you may also see noise like effects on the data that can't
be filtered. It should have a minimum of an RC filter. More than
one stage will give sharper cutoff.
In any case, look up sampling theory. Once you get noise from
not band limiting the input, you can't get it out of the data with
digital filters.
Dwight

5
6 
readingso[readIndexo] = analogRead(oilpressure);

Try making this:

readingso[readIndexo] = .75*readingso[readIndexo] + .25*analogRead(oilpressure);

Another thing to do is limit the rate at which readings are taken so that this behaves consistently.

7

thanks guys sorry for the lack of response. I will try this out tomorrow and see what i can make of it. Will repost the results

8

Also, it looks like you could use the map command and remove a bunch of code.

As I recall, the oil pressure sensor in a car is a pulse type sender.
Don't know why I didn't think about this earlier.
It has a switch contact, a bimetallic piece, resistance wire wrapped around the
bimetal piece and a spring loaded piston from the oil.
The harder the oil pushes on the spring, the longer percentage of time the wire
has to heat the bimetal to open the switch. When the switch opens,
the bimetal piece cools down and the switch closes.
So, reading it with an analog input will be real noisy, since it is really a pulsed
output instead of a continuous output.
The pressure is a percentage of the on to off of the sensor.
You need to be measuring digital time not voltage. I don't know what the
cycle time of the on/off is but I'd think it is on the order of one tenth to a
second someplace so measuring milliseconds would be best.
You'd measure the ratio of on to off. The frequency changes with pressure
as well. It has a higher frequency as the pressure goes up but measuring
the on/off ratio is what the meter on the dash does by having a slow
response time.
If you really wanted to measure with the analog, put an RC filter between
the sensor and the input with a TC of about 1 second.
Dwight