All floats feedback a rounded down integer

Question

So I am very confused at the results I am getting. It seems that floats aren't working properly, and I don't understand why.

I was trying to read a temp sensor and convert the reading to celsius. However, when I tried to divide the value (an int between 145-165) by 1024, and multiply by 5 I would get back a float value of 0.00 Here's the code I was using

    void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(A0, INPUT);

}

void loop() {
  int sensorVal = analogRead(A0);
    Serial.print("Sensor Value: ");
    Serial.println(sensorVal);

  float voltage = ((sensorVal/1024) * 5);
    Serial.print("Voltage Value: ");
    Serial.println(voltage);

}

This would only return values of 0.00 for voltage, even though the sensor itself is working fine, returning varying values between 146 and 165 based on how much heat I apply. This didn't make any sense, so I tried it with some other values, eg.

Serial.print(float (10 / 6));

and

Serial.print(float (5 / 2));

which should have returned 1.67 and 2.50 respectively, but instead returned 1.00 and 2.00

I think it might be a settings thing, where all floats round down to an int, but that seems really weird.

Any help would be great!

Answer 1

You are doing integer arithmetic. Try adding .0 to the end of your values where you need the floating point results.

For example...

  float voltage = ((sensorVal/1024.0) * 5.0);

Remember the results of analog read is an integer. So the conversion to a float in you original code only happens when the "=" is being "executed". Another possibility is to cast it to a float straight away.

  float voltage = ((((float)sensorVal)/1024.0) * 5.0);

Or more simply

  float voltage = ((float)sensorVal)/1024.0 * 5.0;

Answer 2

You already got a couple of perfectly good answer. I will nevertheless suggest a slightly different idiom:

float voltage = sensorVal * (5.0 / 1024);

or, maybe better:

const float V_REF = 5.0;  // at the top of the sketch

float voltage = sensorVal * (V_REF / 1024);

The reason this is slightly better than the other options is because division – even integer division – is a very expensive operation on the smaller Arduinos. By writing the conversion as in the lines above, the ratio V_REF / 1024 becomes a compile-time constant, which is evaluated by the compiler at build time. Then, only the much cheaper multiplication needs to be done by the Arduino itself, at run time. Not a big deal if you are not time constrained, but it's a low-hanging fruit in terms of optimization.

You may write 1024.0 instead of 1024 if it feels safer. I tend to keep the .0 for the voltage only, because 1024 is an integer, whereas the “5” in “5 volts” is conceptually a real number (it's an analog voltage, and not even exactly 5 V if you bother to measure it). But this is just a personal preference at the end.

Answer 3

GMc explained what to do, but didn't explain in detail why your code fails to give floating point results.

Most languages evaluate expressions using order of operations. C and C++ are no exception to this.

In C/C++, while the expression is being evaluated, the compiler also decides what data types to use for each part. integer-integer expressions are evaluated using integer math. If either of the parts of an expression is a larger/floating point type, both values are "promoted" to the larger/more complex type before evaluating the expression.

in your code

float voltage = ((sensorVal/1024) * 5);

The sensorVal/1024 bit is evaluate first. Since both sensorVal and 1024 are integers, the compiler uses integer math. That yields an int result, and so any fractional part is truncated and lost.

It then evaluates result*5 (where result is the result of the first part, sensorVal/1024, which is an integer.) Both of those parts are integers, so the result of that expression is an int.

Finally, you ask the compiler to store the result into a float, voltage. The compiler then promotes the integer result of the whole expression to a float, but you've lost any floating point part of your calculations.

By rewriting your line as

float voltage = ((sensorVal/1024.0) * 5.0);

The compiler does what you want. The sensorVal/1024.0 bit is now integer-float math, so the compiler "promotes" sensorVal to a float and then does float-float math. The second part is now float-float, so the result is also floating point.

float voltage = ((sensorVal/1024.0) * 5);

Would also work in this case (where 5 is an integer constant.) That works because float_result*5 is float-integer math, and the compiler will promote 5 to a floating point value and do float-float math. to get the final result. However, it's safer to use all floating point constants so you don't accidentally do part of your calculations using integer math and truncate that part before converting to floating point.

As you say, making sensorVal a float also would be a good idea. (Again, to avoid accidentally doing integer math on part of your expression and getting wrong results in the process. In this case making sensorVal a float isn't needed, but with a different expression you might wind up with integer math for part of the calculation.)