Arduino arrays

[ajlelectronics]

I can't get my brain to work!

I have a number of approximate numerical values coming in from a sensor. I want to map those to a definite PWM output value. This is for a fuel level converter to match a sender to an incompatible gauge. The gauge is non linear and sender has a ladder of switches and resistors. The figures I am getting on test are as per the table at the bottom.


The sensor value can flicker +- 3 so a simple array won't work unless the values are smoothed first. If I am going to smooth them I might just as well use IF, THEN, ELSE to map the values. Of course we also have the problem of the sender being short of one switch!


The program I am using is one that used to do LPG / fuel switching in my Scimitar, written many years ago. Ignore the "LPG" section, it is disabled by taking D10 high.

/*
LPG_PetrolGauge 24/08/2015
Fuel gauge conversion

The circuit:

Tank sender connected to analogue pin 0 and ground.
330R 1/2W resistor connected from A0 to +5V regulator.
Value varies from 0R full, to 190R empty.

PWM D9 connected via 3K3 resistor to the base of a TIP120.
Emitter grounded, Collector to fuel gauge. Fuel gauge to 12V vehicle power.
created 18/08/15
By Classic Microcars
.
*/
// These constants won't change. They're used to give names
// to the pins used:
const int analogInPin = A0; // Analogue input pin that the petrol sender is attached to
const int analogInPin1 = A1; // Analogue input pin that the LPG sender is attached to
const int analogOutPin = 9; // Analogue output pin that the fuel gauge is attached to
const int alarmLedPin = 13; // Low fuel warning light output.
const int petrolEnablePin = 10; // Input from fuel pump (petrol)

int sensorValue = 0; // value read from the sender
int outputValue = 0; // value output to the PWM (analog out)
int outputValue1 = 0; // value output
int val = 0; // Tank switch value

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
pinMode(alarmLedPin, OUTPUT);
pinMode(petrolEnablePin, INPUT);
}
void loop() {
val = digitalRead(petrolEnablePin);
if (val == LOW) {

lpgSender();
}
else {
petrolSender();
}
}
void petrolSender(){
// read the analog in value:
sensorValue = analogRead(analogInPin);
// map it to the range of the analog out:
outputValue = map(sensorValue, 370, 0, 108, 1); // Calibration to the actual petrol sender
// Alarm threshold SensorValue of 45 to put the LED on

if (sensorValue < 45) {
digitalWrite(alarmLedPin, HIGH);
}
else
{digitalWrite(alarmLedPin, LOW);
}
// change the analog out value:
analogWrite(analogOutPin, outputValue);
// print the results to the serial monitor:
Serial.print("sensor = " );
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);
// wait 2 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(2);
}

void lpgSender(){
// read the analog in value:
sensorValue = analogRead(analogInPin);

// map it to the range of the analog out:
outputValue = map(sensorValue, 1023, 0, 1, 108); // Calibration to the actual LPG sender
// Alarm threshold SensorValue of 226 to put the LED on

if (sensorValue > 225) {
digitalWrite(alarmLedPin, HIGH);
}
else
{digitalWrite(alarmLedPin, LOW);
}
// change the analog out value:
analogWrite(analogOutPin, outputValue);
// print the results to the serial monitor:
Serial.print("sensor = " );
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);
// wait 2 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(2);
}

Fuel level	PWM output for correct display	Sensor input
Empty	1	1
1/8	13	128
1/4	18	170
3/8	22	210
1/2	27	246
5/8	39	279
3/4	50	324
7/8	64	363
Full	108	No more steps

 

[pint]

i mapped the gauge pwm to the sender reading on mine with a bit of maths, easier on mine as they're both linear. I'd be tempted to just if/else with ranges because simple innit and it's only 8 steps.
don't think the missing switch will matter much, the empty end is the important one

Spoiler: code i can't even remember doing

//Fuel Gauge Interface V0.1
//
//1/6/2020
//
// ldv tank to toyota gauge
//
//for Attiny85
//
//

#define pwm_out_pin 1
#define fuel_level_read_pin A2

int gauge_level, fuel_level;

void setup() {

pinMode(pwm_out_pin, OUTPUT);
pinMode(fuel_level_read_pin, INPUT);

}

void loop() {

fuel_level = analogRead(fuel_level_read_pin);
gauge_level = int((0.473 * fuel_level)-180);
analogWrite(pwm_out_pin, gauge_level);
delay(100);

}

 

[eSCHEn]

I would personally just write a pure function and use drop-through calls which return based on the value you need. Everything is sequential so it makes it a lot easier to sort. I’m writing this on a mobile so it won’t be correct but something like:

unsigned char MapFuelSensorValueToPwmOutputValue(const unsigned short fuelSensorValue)
{
  if ( fuelSensorValue < 2 ) return 1;
  if ( fuelSensorValue < 129 ) return 13;
  if ( fuelSensorValue < 171 ) return 18;
  // other cases…
  if ( fuelSensorValue < 364 ) return 64;

 return 108;
}

 

[ajlelectronics]

I would personally just write a pure function and use drop-through calls which return based on the value you need. Everything is sequential so it makes it a lot easier to sort. I’m writing this on a mobile so it won’t be correct but something like:

unsigned char MapFuelSensorValueToPwmOutputValue(const unsigned short fuelSensorValue)
{
  if ( fuelSensorValue < 2 ) return 1;
  if ( fuelSensorValue < 129 ) return 13;
  if ( fuelSensorValue < 171 ) return 18;
  // other cases…
  if ( fuelSensorValue < 364 ) return 64;

 return 108;
}

Thank you. It was a way I had considered, but thought I could do it "nicer". It did occur to me late last night that although the gauge has 8 divisions, there is no reason why I can't divide the gauge drive by seven instead. More thought required!

 

[ajlelectronics]

i mapped the gauge pwm to the sender reading on mine with a bit of maths, easier on mine as they're both linear. I'd be tempted to just if/else with ranges because simple innit and it's only 8 steps.
don't think the missing switch will matter much, the empty end is the important one

Spoiler: code i can't even remember doing

//Fuel Gauge Interface V0.1
//
//1/6/2020
//
// ldv tank to toyota gauge
//
//for Attiny85
//
//

#define pwm_out_pin 1
#define fuel_level_read_pin A2

int gauge_level, fuel_level;

void setup() {

pinMode(pwm_out_pin, OUTPUT);
pinMode(fuel_level_read_pin, INPUT);

}

void loop() {

fuel_level = analogRead(fuel_level_read_pin);
gauge_level = int((0.473 * fuel_level)-180);
analogWrite(pwm_out_pin, gauge_level);
delay(100);

}

Very interesting, thank you. I am leaning towards a divide by seven for the PWM now. When my brain wakes up in a bit, I will see what I can come up with.

 

[eSCHEn]

Fancy maths to convert makes it look neat and gives the brain some happy juice but a focused pure function is easy to read, test and debug. And you get to move on to the next problem to sort.

 

[daedalusminos]

It's relatively straight forward.....consider this, your input is in discrete steps albeit with a bit of variation due to noise in the converted O/P. The sensor is most likely a resistive ladder with a wiper - naturally like a pot there is end error. Looking at your result the sensor is linear (to an approximation) away from the ends:

y=mx+c
x=y-128/39.17
x is then your array pointer 1-6. You have to test for <128 (array pointer = 0) and > 363 (array pointer = 7) first - you might want to outset these values to give a better approximation.

Load the array with your PWM values. Use a time averaged filter to interpolate the PWM value to give 'infinite' gauge readout

 

[daleyd]

Can you use a switch/case statement?

I’ve not done much with arduino other than mess around but I’ve done a lot with plc (structured text) with analogue values and I’ve used a lot of CASE to evaluate a value and do something based on that. It can save doing a load of if…else, in the right circumstances

I had to google what it was called in an arduino so I think that’s correct.

 

[daedalusminos]

This might help explain...

 

[sako243]

@ajlelectronics its just a simple interpolation function. That might be the missing word to start hunting around for how to do it.

If your bouncing about by +/-3 then perhaps just do a running average of 3 of more samples. Basically a low pass filter.

Alternatively you can do maths to map it and use an array to look it up. I do that for a power steering controller we build, basically scale the ADC value up to 8 bits and then drop the least significant 4 bits. The upper 4 bits are then used as a lookup index into a 16 entry array to set the pwm frequency.

 

[ajlelectronics]

It's relatively straight forward.....consider this, your input is in discrete steps albeit with a bit of variation due to noise in the converted O/P. The sensor is most likely a resistive ladder with a wiper - naturally like a pot there is end error. Looking at your result the sensor is linear (to an approximation) away from the ends:

It is a shaft with resistors and reed switches by the seem of it. The "float" has a magnet in it to operate the reeds.. It is not continuously variable but seven steps as the float moves up. 190R at the bottom and 0R at the bottom.

y=mx+c
x=y-128/39.17
x is then your array pointer 1-6. You have to test for <128 (array pointer = 0) and > 363 (array pointer = 7) first - you might want to outset these values to give a better approximation.

Load the array with your PWM values. Use a time averaged filter to interpolate the PWM value to give 'infinite' gauge readout

Yes, I think that the values need smoothing.

 

[ajlelectronics]

This might help explain...
View attachment 502256

Of course I should have done that! Many thanks.

 

[ajlelectronics]

 

[MetalMonkey]

You could do something simple with a 2D array to map the values:

// Define your values in a global 2D array.
int fuelLevelMap[2][9]={{1,128,170,210,246,279,324,363},{1,13,18,22,27,39,50,64,108}};


void setup() {

  Serial.begin(9600);
}

// Function to return corresponding  pwm value for given sensor value
int pwmLookup(int sensorValue){
  int pwmValue=0;
   for (int i=0; i<9; i++) {
      pwmValue = fuelLevelMap[1][i];
      if (fuelLevelMap[0][i] >= sensorValue) { break; }
  }
  return pwmValue;
}


void loop() {

  // get reading from youur sensor into currentSensorInput
  int currentSensorInput;
  int previousSensorInput = 0;
  int pwmOutput = 0;
  // Test loop to iterate through your values  -replace this with a while loop to monitor your sensor
  for (int i=1; i<364; i++) {
    currentSensorInput = i;
    Serial.print("Sensor Input=");
    Serial.print (i);
  
    Serial.print(" PWM Output=");
    Serial.println (pwmOutput);
  
    // Do a dead band test with your +/- 3 threshold.
    if ((currentSensorInput >= previousSensorInput+3) || (currentSensorInput <= previousSensorInput-3)) {
      pwmOutput = pwmLookup(i);
      previousSensorInput = currentSensorInput;
    }
  }
  delay (2000);
}

 

[ajlelectronics]

Settled on this...

/*
Fuel gauge conversion

The circuit:
* Petrol tank sender connected to analog pin 1 and ground.
330R 1/2W resistor connected from A1 to +5V regulator.
Sender value 7 steps from 0R full, to 190R empty

PWM D9 connected via 2K resistor to the base of a TIP120.
Emitter grounded, Collector to fuel gauge. Fuel gauge to 12V ign supply..
created by Classic Microcars 2025
*/
// These constants won't change. They're used to give names
// to the pins used:
const int analogInPin = A0; // Analogue input pin that the petrol sender is attached to
const int analogOutPin = 9; // Analogue output pin that the fuel gauge is attached to
const int alarmLedPin = 13; // Low fuel warning light output.

int sensorValue = 0; // value read from the sender
int outputValue = 0; // value output to the PWM (analog out)
int outputValue1 = 0; // value output
int val = 0; // Tank switch value
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
pinMode(alarmLedPin, OUTPUT);
}
void loop() {
petrolSender2();
}
void petrolSender2(){
// read the analog in value:
sensorValue = analogRead(analogInPin);
if (sensorValue <10){ outputValue = 0;} // Indicate EMPTY
if ((sensorValue >120) && (sensorValue <140)){ outputValue =20;} // Indicate 1/7
if ((sensorValue >160) && (sensorValue <185)){ outputValue =33;} // Indicate 2/7
if ((sensorValue >240) && (sensorValue <260)){ outputValue =39;} // Indicate HALF
if ((sensorValue >260) && (sensorValue <285)){ outputValue =43;} // Indicate 5/7
if ((sensorValue >320) && (sensorValue <335)){ outputValue =67;} // Indicate 6/7
if (sensorValue >350){ outputValue = 108;} // Indicate FULL
if (sensorValue < 140) {
digitalWrite(alarmLedPin, HIGH);
} else {
digitalWrite(alarmLedPin, LOW);
}
// change the analog out value:
analogWrite(analogOutPin, outputValue);
// print the results to the serial monitor:
Serial.print("sensor = ");
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);
// wait 2 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(2);
}

 

[MetalMonkey]

If you are going down the route of multiple IF statements, you could look at using Switch..Case as a little more elegant solution.
Not quite as elegant as the 2D array, but hey.

 

[daleyd]

If you are going down the route of multiple IF statements, you could look at using Switch..Case as a little more elegant solution.
Not quite as elegant as the 2D array, but hey.

That was my suggestion earlier.

 

[ajlelectronics]

That was my suggestion earlier.

Yes, but come on, that needed me to get my brain out of reverse gear! I will look again at your very kind suggestions, to enhance my learning if nothing else. I am most grateful to you all for your suggestions.