[PIC] PIC 16F887 > LM335 > Can not display value of more than 1 decimal

betwixt said:

If your application leaves enough memory to use, try the 'sprintf' instruction to convert floating point numbers to strings. It can also add fixed text to the display in the process.
For example:

Code:

sprintf(TextToLCD,"Temperature is %fC", temp);

if 'temp' is 1.234 the character string 'TextToLCD' will become 'Temperature is 1.234C'.

Note that you can apply formats to the %f substitution, for example changing it to %02.3f will display up to two leading zeroes and 3 decimal places.

Brian.

Click to expand...

Aussie Susan said:

You are calculating 'temp' as a floating point value but passing it to 'print_float_v11' which expects a 'long' (aka integer) value. You might be getting an automatic conversion (or garbage value) but assuming that your program is working as expected, then you will need to scale the 'temp' by a factor of 10 or 100 if you want those additional decimal values.
For example, if you have temp = 1.234 and want 2 decimal places, then the integer that the function needs to deal with must be 123 - i.e. the value multiplied by 100. Of course this may need to be adjusted to allow for the rounding for the dropped decimal place - i.e. if you want 1.237 to print as "1.24" then you need to pass 124 as the integer to your function.
Also your function needs to be altered to calculate the various values correctly, rather than (as you have it now) assuming a specific scaling factor and using literal '0' characters.
Following on from @betwixt's suggestion (to use sprintf), that function will probably call 'ftoa' to do the actual work. There are several source code versions of this function on the internet that you can use instead of yours, that will be a lot more flexible and handle being passed a floating point number, rather than a scaled integer.
Susan

Click to expand...

Aussie Susan said:

You are calculating 'temp' as a floating point value but passing it to 'print_float_v11' which expects a 'long' (aka integer) value. You might be getting an automatic conversion (or garbage value) but assuming that your program is working as expected, then you will need to scale the 'temp' by a factor of 10 or 100 if you want those additional decimal values.
For example, if you have temp = 1.234 and want 2 decimal places, then the integer that the function needs to deal with must be 123 - i.e. the value multiplied by 100. Of course this may need to be adjusted to allow for the rounding for the dropped decimal place - i.e. if you want 1.237 to print as "1.24" then you need to pass 124 as the integer to your function.
Also your function needs to be altered to calculate the various values correctly, rather than (as you have it now) assuming a specific scaling factor and using literal '0' characters.
Following on from @betwixt's suggestion (to use sprintf), that function will probably call 'ftoa' to do the actual work. There are several source code versions of this function on the internet that you can use instead of yours, that will be a lot more flexible and handle being passed a floating point number, rather than a scaled integer.
Susan

Click to expand...

To be honest, I founded a routine that paulfjugo dropped in a former discussion. But I do not understand almost nothing …

Click to expand...

void float2aascii (float x, unsigned char *str, char precision)
{
 // Converts a floating point number to an ASCII string.
 // Version limited at 5 decimals maximum.
 // x is stored into str, which should be at least 30 chars long.

 int ie, i, k, ndig;
 double y;

 if (precision >= 5)
    {
     precision = 5;
    }
    else
          {
           precision++;
          }

 ndig = precision;

 ie = 0;

 // If x is negative, write minus and reverse.
 
if (x < 0.00000)
    {
     *str++ = '-';
     x = -x;
    }
 
// Put x in range 1 <= x < 10.

 if (x > 0.000000)
    {
     while (x < 1.000000)
     {
      x *= 10.000; // 🤔 A la place de =*
      ie--;
     }
    }

 while (x >= 10.0000)
 {
  x = x / 10.0000;
  ie++;
 }

 // In f format, number of digits is related to size.

 ndig += ie; // 🤔 A la place de =+
 
// round x is between 1 and 10 and ndig will be printed to right of decimal point …
 
 for (y = i = 1; i < ndig; i ++)
       {
        y = y / 10.0000;
       }

 x += y / 2.0000; // 🤔

 if (x >= 10.0000)
    {
     x = 1.0000;
     ie++;
    }

 if (ie < 0)
    {
     *str++ = '0';
     *str++ = '.';
     if (ndig < 0)
        {
         ie = ie - ndig;
        }
     for (i = -1; i > ie; i --)
           {
            *str++ = '0';
           }
    }

 for (i = 0; i < ndig; i ++)
        {
         k = x;
         *str++ = k + '0';
         if (i == ie)
            {
             *str++ = '.';
            }
         x -= (y = k); 🤔
         x *= 10.0000;
        }
      
 *str = '\0'; 🤔
}

Aussie Susan said:

Good on you for not just using the code blindly but wanting to understand how it works.
I would start by thinking how you would go about this with a pencil and paper.
I think you have a specific problem with understanding the syntax such as 'ndig += ie;'. This is standard 'C' and is equivalent to (in this case) 'ndig = ndig + ie'. Of course the '+=' can be any of the normal numeric and bit manipulation operators ('*", '/', '&' etc.).
"*str = '\0'; " puts a null character at the end of the string which, by convention, indicates the end of the string.
The "x -= (y = k);" is doing two things at once. The 'y = k' part id a standard assignment. Also remember that the result of an assignment is the value itself (which means that code such as 'a = b = c = 0;' will set 'a', 'b' and 'c' all t 0). Once the assignment has been done this becomes equivalent to 'x -= k' which is the structure described above.
Susan

Click to expand...

Aussie Susan said:

Good on you for not just using the code blindly but wanting to understand how it works.
I would start by thinking how you would go about this with a pencil and paper.
I think you have a specific problem with understanding the syntax such as 'ndig += ie;'. This is standard 'C' and is equivalent to (in this case) 'ndig = ndig + ie'. Of course the '+=' can be any of the normal numeric and bit manipulation operators ('*", '/', '&' etc.).
"*str = '\0'; " puts a null character at the end of the string which, by convention, indicates the end of the string.
The "x -= (y = k);" is doing two things at once. The 'y = k' part id a standard assignment. Also remember that the result of an assignment is the value itself (which means that code such as 'a = b = c = 0;' will set 'a', 'b' and 'c' all t 0). Once the assignment has been done this becomes equivalent to 'x -= k' which is the structure described above.
Susan

Click to expand...

Aussie Susan said:

Code:

for (y = i = 1; i < ndig; i ++)
       {
        y = y / 10.0000;
       }

Break it down. The 'y = i = 1' part we dealt with earlier - this is just an assignment to both the 'y' and the 'i' variables with the numeric value of 1.
The rest is a fairly standard 'for' loop that initialises 'i', check that it is less than the value of 'ndig', performs the loop and then increments 'i' by 1.
So really the only 'strange' part is the assignment of 'y' to an initial value or 1 along with the loop variable.
The loop part is probably written with more trailing 0's of the floating point value (it could be '10.0' and be just the same) than necessary but that is not 'wrong as such.
This is all basic 'C' - I suggest that you get a good beginner's book or tutorial on 'C" and read through that.
Susan

Click to expand...

Aussie Susan said:

Good on you for not just using the code blindly but wanting to understand how it works.
I would start by thinking how you would go about this with a pencil and paper.
I think you have a specific problem with understanding the syntax such as 'ndig += ie;'. This is standard 'C' and is equivalent to (in this case) 'ndig = ndig + ie'. Of course the '+=' can be any of the normal numeric and bit manipulation operators ('*", '/', '&' etc.).
"*str = '\0'; " puts a null character at the end of the string which, by convention, indicates the end of the string.
The "x -= (y = k);" is doing two things at once. The 'y = k' part id a standard assignment. Also remember that the result of an assignment is the value itself (which means that code such as 'a = b = c = 0;' will set 'a', 'b' and 'c' all t 0). Once the assignment has been done this becomes equivalent to 'x -= k' which is the structure described above.
Susan

Click to expand...

Eric_O said:

I understand mostly all C instruction, and otherwise I use tutorial on line or help menu of MikroC compiler.
The problem with this routine is more the principe used for conversion, how the conversion is managed, the différents steps / cases, with the several for loops one after one.

--- Updated Dec 9, 2022 ---

Thanks for explanations.

Click to expand...

Eric_O said:

I understand mostly all C instruction, and otherwise I use tutorial on line or help menu of MikroC compiler.
The problem with this routine is more the principe used for conversion, how the conversion is managed, the différents steps / cases, with the several for loops one after one.

--- Updated Dec 9, 2022 ---

Thanks for explanations.

Click to expand...

Aussie Susan said:

Good on you for not just using the code blindly but wanting to understand how it works.
I would start by thinking how you would go about this with a pencil and paper.
I think you have a specific problem with understanding the syntax such as 'ndig += ie;'. This is standard 'C' and is equivalent to (in this case) 'ndig = ndig + ie'. Of course the '+=' can be any of the normal numeric and bit manipulation operators ('*", '/', '&' etc.).
"*str = '\0'; " puts a null character at the end of the string which, by convention, indicates the end of the string.
The "x -= (y = k);" is doing two things at once. The 'y = k' part id a standard assignment. Also remember that the result of an assignment is the value itself (which means that code such as 'a = b = c = 0;' will set 'a', 'b' and 'c' all t 0). Once the assignment has been done this becomes equivalent to 'x -= k' which is the structure described above.
Susan

Click to expand...

i = 1;
y = i;  // Thse two lines are the first part of the 'for' loop and initialise variables
while(i < ndig)  // This applies the 2nd part - the test - to see if we go through the loop (again)
{
    y = y / 10.00;  // This is the code that is inside the loop
    i++;      // The 3rd part of the 'for' statement - this typically updates the loop variable
}

Eric_O said:

y also increased as + 1 like i ?

Click to expand...

i = 1; y = i; // Thse two lines are the first part of the 'for' loop and initialise variables while(i < ndig) // This applies the 2nd part - the test - to see if we go through the loop (again) { y = y / 10.00; // This is the code that is inside the loop i++; // The 3rd part of the 'for' statement - this typically updates the loop variable }

Aussie Susan said:

Thank you for your lighting Susan. Here I am reassured. Indeed, I didn't really like writing this loop with the for instruction. Yesterday I thought that a while loop was better, and simpler. But I preferred to wait for your answer. Usually I prefer the while over the for. And the initialization of variables i and y is clearer as well.

Click to expand...

Aussie Susan said:

There is nothing wrong with using a 'for' loop, and it is probably 'neater' than using the equivalent 'while' loop as all of the key parts are all in the one place. However the choice is your as the coder - but remember that you or someone else may need to update your code in the years to come so making it understandable is a good thing.
The only reason I used the equivalent 'while' loop was to show you where the 'y' variable was actually used and why your comment about it being incremented by 1 was wrong.
Susan

Click to expand...

Aussie Susan said:

Point #1: you could do that but that would also extend the size of the 'then' block (i.e. the part that is executed if the boolean in the 'if' statement is true). One thing that makes code more understandable is to keep blocks short and to keep then to one process.

Point #2: You need to understand what the 'x' and 'y' variables contain. The comment immediately above that code section indicates what is happening. The variable 'x' contains the absolute original value normalised to be greater than or equal to 1 and less than 10. (By the way, your first comment above has mis-copied the original comment. In programming, even in comments, accuracy is vital.) The variable 'y' indicates where the decimal point should be given the normalised 'x'.
For example, if the original number is 123.45 and the precision is 1 (i.e you want 1 digit displayed after the decimal point which would make 'ndig' - the total number of digits - 2), then 'x' would be 1.2345 and 'ie' would be 2 at the end of your loop in point 1. That means you have effectively shifted the decimal point 2 places right and this needs to be taken into account. That is why 'ndig' (which is the original precision [ignoring the +1 that accounts for the decimal point]) needs to be increased by 2 to make it 3. That means the decimal point needs to be printed after the 3rd numeric digit.
Now we get to why the 'divide by 2'. In the loop you were asking about before, 'y' starts as 1 and is divided by 10 'ndig - ' times so it becomes 0.001 in the example above. Look what happens when you divide that by 2 - it becomes 0.0005. How when you add that back to the 'x' value you get '1.2345 + 0.0005' which is 1.2350.
If the original number was 123.44, then it would now be 1.2349, and if the original umber was 123.46, it would become 1.2351.
Why is tis important - remember that we only want 1 digit after the printed decimal place which means that we will be (in this example) printing 4 digits (plus the decimal point) That makes all of the example values rounded to the last displayed digit. If the last digit of the 'x' value was between 0 and 4 then it will round the number down; if it was between 5 and 9 then the number is rounded up.

Point #3: after all the rounding, what if the original number was 99.95 and you wanted 1 decimal place. We have already made 'x' to be between 1 (inclusive) and 10 (exclusive) so it would be '9.995'. We now round that (as described before) and we now have 'x' become '10.00'. That is now equal to the upper bound for 'x' (remember that the upper bound is exclusive) so we bring it back to '1.000' and increment 'ie' to show that we have made another left shift.

What I strongly recommend what you do is to get a pencil and paper, start with some values for the function parameters - in my example above I started with the number 123.45 and a precision of 1 - and then create some columns for each of the variables involved putting in the numbers with each step. at step through the code update the numbers according to the statement and you will see how the code is working. (By the way, that is exactly what I did in working through my example above to make sure I had the right numbers.)
Do this with several initial numbers so that you go through all of the code paths.

Susan

Click to expand...

Aussie Susan said:

Code:

for (i = 0; i < ndig; i ++)
        {
         k = x;
         *str++ = k + '0';
         if (i == ie)
            {
             *str++ = '.';
            }
         x -= (y = k); 🤔
         x *= 10.0000;
        }

As before, using a pencil and paper and stepping through the code yourself wil show you what is happening.

Lets recall what some of the variables mean:
- ndig is the number of digits to be displayed
- x is the normalised value (i.e. the initial value that is now 1 <= x < 10
- str is a pointer to the output string

The 'for' loop should be understandable now.

The 'k = x' line may need as bit of explanation. Recall that 'x' is a floating point number, and looking back you can see that 'k' has been declared as an integer. When you assign a real to an integer, it will truncate the value - in other words it will keep any integer part and simply ignore any fractional part. For example. 3.65 will become 3.

The '*str++' for a pointer does two things. Firstly the '*' will dereference the pointer so that (in this case) the assignment will be to the memory location where 'str' is pointing. The is the output character string location. The '++' means that, after (in this case) the assignment, the pointer wil be incremented to the next address. AS this is a pointer to a character, the pointer will move to the next character position.
Now, what is assigned at the location? That is the "k + '0'" part. K is the binary integer we want to display but we need to convert it to as human readable ASCII value. If you look at an ASCII table, you will see that the digits are in their normal ascending sequence, tarting with '0'. Therefore adding '0' to the binary value will make it the ASCII equivalent: binary 4 will become "4" and so on. Therefore we are converting the binary digit to its ASCII equivalent and storing it in the output string.

The next 'if' statement looks to see if we are at the point in the output string where we need to put in the decimal point. (They are assuming the "." character is used whereas I know the Europeans often use ",".)

The 'x -= (y = k);' line needs a bit of explanation. As always you start within the brackets so we assign 'y' the value of 'k'. 'k' is the digit we have just "printed" but is an integer. It is quite acceptable to subtract a integer from a floating point number but in this case they have elected to convert the integer to the equivalent double precision value 'y' via the assignment. So it is the double precision value that is now subtracted from 'x'.

If 'x' was '3.65', then 'k' would have been '3' and "3" is what would have been added to the string. 'y' would be 3.0000 and this is what is subtracted from 'x' - so 'x' now becomes 0.65.

As the loop assumes we are using a normalised value, we multiply 'x' by 10 - in our example 0.65 will now be 6.5 - and we start the loop all over again.

The statement that is just outside the loop "*str='\0';" will write a null character at the end of the printed string. In C that is the convention to terminate a string.

Susan

Click to expand...