Floating Points and rounding

[JBotAlan]

Originally Posted by chapmatr

If you're dealing with the FRC controller, you can't deal with signed or floats (unless something's changed), just integers. You'll have to multiply your numbers by 10^n, [i]n/I] of the number of decimals you want. Please, correct me if I'm wrong, this is my first official year as a programmer.

You aren't *supposed* to use floats, because the processor doesn't natively do floating point calculations, but the compiler spits out code that works. I need to learn assembler and look at the output, but I don't have time for that right now. Signed variables are fine AFAIK. They work, too.

JBot

[Dave Flowerday]

Originally Posted by JBotAlan

You aren't *supposed* to use floats, because the processor doesn't natively do floating point calculations, but the compiler spits out code that works.

The problem here is that on a processor that supports floating-point math, doing any floating-point arithmetic takes a single assembly operation. On processors that don't support it (like the RC processor), it has to be done in software. So, each time you do anything with a floating point number, the compiler will end up generating a LOT of code to do it (something like 100 lines of assembly instead of just one). This uses up a lot of extra code space and is obviously a lot slower.

The answer has already been provided here. If you need 1/10 accuracy, just multiply all of your numbers by 10. Also, if you're trying to multiply something by a fraction, but the result only needs to be an integer, keep this trick in mind. If you're multiplying by a fraction, you can multiply by the numerator first and then divide by the denominator afterwards to avoid floating point (just be careful of overflows). So when someone here was talking about multiplying by 180/127, do this instead:

(x * 180) / 127

[charrisTTI]

The compiler can do some of the floating point calculations you might like to do keep your code readable. Note I said compiler, not the controller. The calculations are done once at compile time, and the resulting long, short, char value is used in the code.

Here is an example using an encoder to control distance moved in autonomous code:

In xxx.h the following macros are defined:

#define COUNTS_PER_REVOLUTION 100.0
#define PI 3.14159
#define WHEEL_DIAMETER 5.25
#define INCHES_TO_COUNTS( inches ) ( inches / ( PI * WHEEL_DIAMETER ) ) * COUNTS_PER_REVOLUTION

enum MoveDirection
{
MoveForward,
MoveRotateCW,
MoveRotateCCW,
MoveReverse
};

void Move( enum MoveDirection directionParam, unsigned char speedParam, unsigned short distanceParam );

In yyy.c is a section of a switch statement used to implement a state machine for autonomous mode


case 3:
// move forward 45 inches
Move( MoveForward, 0x20, INCHES_TO_COUNTS( 45.0 ) );
break;


The macro INCHES_TO_COUNTS allows the compiler to do the floating point math once at compile time to determine how many encoder counts are required for the wheel to move 45 inches.

Now assuming a wheel base of 18 inches how would you code the macro for
DEGREES_TO_COUNTS so that we could write:

case 4:
// turn right 90 degrees
Move( MoveRotateCW, 0x20, DEGREES_TO_COUNTS( 90.0 ) );
break;