嵌入式系统中的浮点错误

Question

On a Rabbit microcontroller.. (1) I am incrementing f1 every second by converting into hours to the existing value and store in the same register.

void main()
{
    float f1;
    int i;
    f1 = 4096;
    // Assume that I am simulating a one second through each iteration of the following loop
    for(i = 0; i < 100; i++)
    {
        f1 += 0.000278; // f1 does not change from 4096
        printf("\ni: %d f1: %.06f", i, f1);
    }
}

(2) Another question is when I try to store a 32-bit unsigned long int value into float variable and accessing it does not give me the value I have stored. What am I doing wrong?

void main()
{
    unsigned long L1;
    int temp;
    float f1;

    L1 = 4000000000; // four billion
    f1 = (float)L1;

    // Now print both
    // You see that L1: 4000000000 while f1: -4000000000.000000
    printf("\nL1: %lu f1:%.6f", L1, f1);
}

Answer 1

The first problem is that single precision (32 bit) binary floating point is good for only approximately 6 significant figures in decimal. So if you start with 4096.00 anything less than .01 cannot be added to the value. Using double precision will improve the result at some significant cost.

It is usually unnecessary and inappropriate to use floating point, it is very expensive on a processor without an FPU - especially an 8 bitter. Moreover your literal approximation of one second in hours (1.0f/3600.0f hours) will introduce significant cumulative error in any case. You may be better off storing time in integer seconds, and converting to hours where necessary for display or output.

The second problem is less clear, but seems likely to be an issue with the Rabbit compiler implementation of floating point or possibly of the %f format specifier in the printf() implementation. Check the ISO compliance statement in the compiler documentation - there may be restrictions - especially on floating point. Again you may find that using a double resolve the problem - especially as strictly that is the type expected by the %f format specifier in an ISO conforming implementation. As I said, you are probably best off avoiding floating point altogether on such a target.

Note that if you are using Rabbit's Dynamic C compiler, you should be clear that Dynamic C is not an ISO conforming C compiler. It is a proprietary C-like language, that is similar enough to C to cause a great deal of confusion! Specifically it does not support double precision ( double ) floating point.

Answer 2

f1 += (1/3600); should be f1 += (1.0f/3600.0f); .

If you perform integer division then result will also be integer.