Jittery map() values

nervusvagus · December 18, 2018, 3:36pm

I'm using the values from a potentiometer and mapping it to 0-255 with very jittery results.

ie.

int Constrainedaverage = constrain(potmovingavg,0,1000);
  Pot1MappedOutputValue = map(Constrainedaverage, 5, 1000, 0, 255);

when the average value read from pot is certain values, for example 550 the map value fluctuates between 139 & 140

pot1RAWValue : 758 / Constrainedaverage : 758 / potmovingavg: 758 / Pot1MappedOutputValue: 192
pot1RAWValue : 759 / Constrainedaverage : 759 / potmovingavg: 759 / Pot1MappedOutputValue: 193
pot1RAWValue : 758 / Constrainedaverage : 758 / potmovingavg: 758 / Pot1MappedOutputValue: 192
pot1RAWValue : 759 / Constrainedaverage : 759 / potmovingavg: 759 / Pot1MappedOutputValue: 193
pot1RAWValue : 758 / Constrainedaverage : 758 / potmovingavg: 758 / Pot1MappedOutputValue: 192
pot1RAWValue : 759 / Constrainedaverage : 759 / potmovingavg: 759 / Pot1MappedOutputValue: 193
pot1RAWValue : 758 / Constrainedaverage : 758 / potmovingavg: 758 / Pot1MappedOutputValue: 192

and with
int Constrainedaverage = constrain(potmovingavg,0,999);
Pot1MappedOutputValue = map(Constrainedaverage, 5, 999, 0, 255);

the map value fluctuates wildly as 197 & 196

pot1RAWValue : 550Constrainedaverage : 550 / potmovingavg: 550 / Pot1MappedOutputValue: 139
pot1RAWValue : 551Constrainedaverage : 551 / potmovingavg: 551 / Pot1MappedOutputValue: 140
pot1RAWValue : 550Constrainedaverage : 550 / potmovingavg: 550 / Pot1MappedOutputValue: 139
pot1RAWValue : 551Constrainedaverage : 551 / potmovingavg: 551 / Pot1MappedOutputValue: 140

I tried understanding what the issue might be from here:

github.com/arduino/ArduinoCore-API

map() function equation wrong

opened 05:37PM - 22 Nov 14 UTC

st42

bug

EDIT NOTE: I added a comment to the end of this from a later comment because I t…hought it should have been included in the first place. The equation in the function stated at http://arduino.cc/en/Reference/Map ``` C++ long map(long x, long in_min, long in_max, long out_min, long out_max) { return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; } ``` is wrong. The example given: ``` C++ val = map(val, 0, 1023, 0, 255); ``` In this example 0-1023 is mapped to 0-255. The equation gets it wrong by mapping 1023 numbers to 255 numbers, when it should be mapping 1024 numbers to 256 numbers. 0 through 1023 is 1024 numbers not 1023 : in_max - in_min : 1023-0=1023 0 through 255 is 256 numbers not 255 : out_max - out_min : 255-0=255 The corrected equation in the function should be: ``` C++ long map(long x, long in_min, long in_max, long out_min, long out_max) { return (x - in_min) * (out_max - out_min + 1) / (in_max - in_min + 1) + out_min; } ``` In the following simpler example it will be easier to see: val = map(val, 0, 3, 0, 1); In this example 0,1,2 and 3 is mapped to 0 and 1. Mapped correctly it should be: 0 maps to 0 1 maps to 0 2 maps to 1 3 maps to 1 Using the equation in the the function as it is now, it is mapped as such: 0 maps to 0 1 maps to 0 2 maps to 0 3 maps to 1 This is a common problem programmers have dealt with before. When dealing with arrays you can not determine array size by simply subtracting first position from last position you will always be off by 1. That is why you add 1 to get proper size. I know this is for the most part a minor problem, but if your project requires accurate results this could be a serious issue. --- Added from later comment--- To give a real world scenario as to why this needs changed consider this. You are using the arduino with a sensor to sample data and based on this data set a servo into 1 of 4 positions. The arduino uses a 10 bit adc and outputs integers from 0 to 1023. You would use map(x, 0, 1023, 1, 4). With the map function as it is currently the only time position 4 would be active is when the arduino outputs the integer 1023. With my proposed change each position would get an equal share of the possible range. When they converted this function from a float function to an integer function they didn't consider that the output is no longer a value but a position. Value mapping maps one value to another and the function works perfectly for floats. Positional mapping distributes the input as evenly as possible to the output and the function as is doesn't do that. This function needs to be split into two functions. One for floats as it is now and one for integers as I proposed.

but exceeded my capacity. Any takers?

Full code below:

//#include "FastLED.h"                                          // FastLED library.
#include <movingAvg.h> 

////////////////////////////////////////////POTENTIOMETER1 / BRIGHTNESS
int pot1 = A5;
int pot1RAWValue  = 0;
int pot1OldRAWValue  = 0;
const int numReadings1 = 10;
int readings1[numReadings1];      // the readings from the analog input
int index1 = 0;                  // the index of the current reading
int total1 = 0;                  // the running total
int average1 = 0;                // the average
int Pot1MappedOutputValue = 32;
int oldPot1MappedOutputValue = 0;
movingAvg potentiometeraverage(25);   
////////////////////////////////////////////POTENTIOMETER1////////////////////////////////////////////






////////////////////////////////////////////////SETUP/////////////////////////////////////////////////

void setup() {
  Serial.begin(57600);
 potentiometeraverage.begin();




  
}////////////////////////////////////////////////SETUP/////////////////////////////////////////////////


////////////////////////////////////////////////LOOP/////////////////////////////////////////////////
void loop() {


   /////////////////////////////////////////////// TGAN_Potentiometer_1
  pot1RAWValue  = analogRead(pot1);  // Serial.print("pot1RAWValue : "); Serial.println(pot1RAWValue );

//Discard the value if its less that +2 of the old value. Removes jittery readings.
 if (abs(pot1RAWValue-pot1OldRAWValue)<= 3) 
   {
   pot1RAWValue = pot1OldRAWValue;
  }
   


 
 int potmovingavg = potentiometeraverage.reading(pot1RAWValue); 
   
int Constrainedaverage = constrain(potmovingavg,0,1000);
  Pot1MappedOutputValue = map(Constrainedaverage, 5, 1000, 0, 255);


 
  if (Pot1MappedOutputValue != oldPot1MappedOutputValue) 
  {
    Serial.print("pot1RAWValue : "); Serial.print(pot1RAWValue );  Serial.print(" / Constrainedaverage : "); Serial.print(Constrainedaverage ); Serial.print(" / potmovingavg: "); Serial.print(potmovingavg); Serial.print(" / Pot1MappedOutputValue: "); Serial.println(Pot1MappedOutputValue);
  }
  oldPot1MappedOutputValue = Pot1MappedOutputValue;
  /////////////////////////////////////// TGAN_Potentiometer_1 ///////////////////////////////////////

}

econjack · December 18, 2018, 3:57pm

I think the values might be expected to vary within a narrow band of values. If you're expecting a stable, unique, value at a constant input value, that's likely not going to happen. Perhaps you could take 25 sample values and display the average or something like that, to make the output appear more stable.

6v6gt · December 18, 2018, 4:00pm

Deriving a stable set of discrete values covering the full range 0 to 255 from a 270 degree sweep potentiometer is pushing it a bit.
Have a look here though: Hysteresis - Introductory Tutorials - Arduino Forum.

jremington · December 18, 2018, 5:11pm

the map value fluctuates wildly as 197 & 196

This is not "wild fluctuation".

For example, if a more accurate representation of the true value would be 196.5, then that is perfectly acceptable measurement noise, and is completely unavoidable.

One popular approach to reducing measurement noise is to average some values, as suggested above.

nervusvagus · December 18, 2018, 5:54pm

I believe I didnt initially pose the question correctly but in any case I did try averaging the final mapped value too and not much changed.

The issue is that the potentiometer at some positions reads jittery values. ie the value fluctuates between 2 incremental values and this causes a lot of issue in final values whether averaged, mapped or not.

I placed a 0.1uf capacitor between ground and input pin of pot and still nothing changed.

pot1RAWValue : 397 / Constrainedaverage : 396 / potmovingavg: 396 / Pot1MappedOutputValue: 100 / Pot1MappedMovingAverage: 100
pot1RAWValue : 396 / Constrainedaverage : 397 / potmovingavg: 397 / Pot1MappedOutputValue: 101 / Pot1MappedMovingAverage: 101
pot1RAWValue : 396 / Constrainedaverage : 396 / potmovingavg: 396 / Pot1MappedOutputValue: 100 / Pot1MappedMovingAverage: 100
pot1RAWValue : 396 / Constrainedaverage : 397 / potmovingavg: 397 / Pot1MappedOutputValue: 101 / Pot1MappedMovingAverage: 101
pot1RAWValue : 397 / Constrainedaverage : 396 / potmovingavg: 396 / Pot1MappedOutputValue: 100 / Pot1MappedMovingAverage: 100
pot1RAWValue : 396 / Constrainedaverage : 397 / potmovingavg: 397 / Pot1MappedOutputValue: 101 / Pot1MappedMovingAverage: 101
pot1RAWValue : 397 / Constrainedaverage : 396 / potmovingavg: 396 / Pot1MappedOutputValue: 100 / Pot1MappedMovingAverage: 100

nervusvagus · December 18, 2018, 6:02pm

I think scrapping any pot raw value if the value is not more than 3 from the previous read value solves it. crude but hopefully does what is needed.

Final code:

//#include "FastLED.h"                                          // FastLED library.


////////////////////////////////////////////POTENTIOMETER1 / BRIGHTNESS
#include <movingAvg.h> 
int pot1 = A5;
int pot1RAWValue  = 0;
int pot1OldRAWValue = 0;
int Pot1MappedOutputValue = 32;
movingAvg Pot1MappedAverage(10);
int oldPot1MappedMovingAverage;
movingAvg potentiometeraverage(25);   
////////////////////////////////////////////POTENTIOMETER1////////////////////////////////////////////



////////////////////////////////////////////////SETUP/////////////////////////////////////////////////
void setup() {
  Serial.begin(57600);
 potentiometeraverage.begin();
 Pot1MappedAverage.begin();
}////////////////////////////////////////////////SETUP/////////////////////////////////////////////////


////////////////////////////////////////////////LOOP/////////////////////////////////////////////////
void loop() {
   /////////////////////////////////////////////// TGAN_Potentiometer_1
  pot1RAWValue  = analogRead(pot1);  // Serial.print("pot1RAWValue : "); Serial.println(pot1RAWValue );

 if (abs(pot1RAWValue-pot1OldRAWValue)<= 3) 
   {
   pot1RAWValue = pot1OldRAWValue;
  }


int potmovingavg = potentiometeraverage.reading(pot1RAWValue); 
int Constrainedaverage = constrain(potmovingavg,0,1000);
Pot1MappedOutputValue = map(Constrainedaverage, 0, 1000, 0, 255);
int Pot1MappedMovingAverage = Pot1MappedAverage.reading(Pot1MappedOutputValue);
  if (Pot1MappedMovingAverage != oldPot1MappedMovingAverage) 
  {
    Serial.print("pot1RAWValue : "); Serial.print(pot1RAWValue );  Serial.print(" / Constrainedaverage : "); Serial.print(Constrainedaverage ); Serial.print(" / potmovingavg: "); Serial.print(potmovingavg); Serial.print(" / Pot1MappedOutputValue: "); Serial.print(Pot1MappedOutputValue); Serial.print(" / Pot1MappedMovingAverage: "); Serial.println(Pot1MappedMovingAverage);
  }
  oldPot1MappedMovingAverage = Pot1MappedMovingAverage;
  /////////////////////////////////////// TGAN_Potentiometer_1 ///////////////////////////////////////

pot1OldRAWValue = pot1RAWValue;
}

Topic		Replies	Views
POTENTIOMETER VALUE VARIANCE. Programming	4	1034	May 5, 2021
Stabilize a mapped ADC value Programming	3	1014	May 5, 2021
Weird reading of potentiometer Sensors	15	4211	May 6, 2021
Using Map function with a potentiometer Programming	5	29687	May 5, 2021
Potentiometer Map Programming	6	3786	May 6, 2021

Jittery map() values

Related topics