Problema con multiplicación de decimales

Estoy teniendo un problema en una operación matemática y no me doy cuenta cual puede ser la cusa
El código:

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

void loop() {
  // put your main code here, to run repeatedly:
int MOD = 25000;
float N = 90.24;
int INT =90;

float FRAC = (( N - (float)INT) * (float)MOD);



Serial.print("FRAC ");
Serial.println(FRAC);


}

El resultado debería ser 6000 pero da 5999.95

alguna idea??

El resultado es normal porque usas float por esto

http://docs.python.org.ar/tutorial/3/floatingpoint.html

Jopapa
El resultado debe ser entero (90,24-90)*25000=debería dar 6000
Voy a leer la documentación haber si entiendo pero no debería pasar
Otro ejemplo es
La misma cuenta (90.24-90)*250 el resultado es correcto da 60 tanto en el Arduino como en la vida real es como que algo esta mal definido

Lo que está ocurriendo es lo que te dice Jopapa. Para comprenderlo plenamente, deberías saber cómo se almacenan los números en coma flotante binaria. Es un tema que requiere un tiempo comprender; pero si intentas sencillamente transformar 0,24 a binario verás que te salen muchiiiiiisimos decimales (probablemente incluso resulte un número binario periódico). Otra cosa es que internamente haya redondeos, que directamente te muestren en pantalla el número que quieres ver, pero a medida que se hacen cálculos con ellos ese pequeño desvío se va notando más, hasta que se ven en pantalla.

Bueno esto es así que le vamos a hacer encontré una posible solución
Como MOD lo obtengo de otra cuenta

unsigned int MOD = ((1000*(_FreqRef / PasoCanal)));

FreqRef , PasoCanal son enteros entonces lo puedo hacer en 2 pares

MOD1 = ((FreqRef / PasoCanal)));
MOD = ((1000*( MOD1)));

N lo obtengo de una división por las pocas pruebas que realice no note el problema de punto flotante con este tipo de operación

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

void loop() {
  // put your main code here, to run repeatedly:
int MOD = 25000;
int MOD1 =25;
float N = 90.16064;
int INT =90;
unsigned long NL= N*100000;
unsigned long INTL=INT*100000;
long NLINTL= NL-INTL;

Serial.print("NL ");
Serial.println(NL);
Serial.print("INTL ");
Serial.println(INTL);
Serial.print("NLINTL ");
Serial.println(NLINTL);

//float FRAC = (( N - (float)INT) * (float)MOD);

unsigned long FRAC =(NLINTL* MOD1)/100;

Serial.print("FRAC ");
Serial.println(FRAC);


}

Por el momento lo que preciso son 5 dijitos de presicion capas que estoy encarando mal todo la parte matemática pero por el momento es lo que me va saliendo
Estoy muy agradecido de que me puedan seguir aconsejando

Si explicas qué intentas calcular tal vez te podamos dar un consejo más específico.

Perón por la demora no es que lo deje colgado pero se termino la licencia y denuedo a trabajar y no me queda mucho tiempo para el hobby
Lo que tengo que calcular son unos parámetros de configuración del generador de clok a partir de la frecuencia que quiero a la salida

El link de la hoja de dato

Lo que quiero calcular esta en la pagina 11

RFOUT = fPFD × (INT + (FRAC/MOD))

fPFD = REFIN × [(1 + D)/(R × (1 + T))]

Este es el código que tengo echo perdonen lo entreverado pero es lo que al momento puedo hacer con el tiempo tratare de mejorar

int _FreqRef=25000 ;//frecuencia de referencia en KHZ
int PasoCanal=100;//frecuencia en khz de los paso de frecuencia
unsigned long RFout=437000;//frecuencia de salida Khz
float PFDFreq=0;


//R0
unsigned long _INT=1440;
int _FRAC= 0;

//R1
int _MOD= 100; 

//R2 de configuracion
unsigned long _RefDBR=0;//esta declarado como  unsigned long para evitar problemas en la rotacion de 32 bit
unsigned long _rdiv2DBR=0;
unsigned long _RCount=1;

// R4 
unsigned long _feedbackType=1 ; 
byte ouputdivid=8;
unsigned long _Rfdivider=3;

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:
  Cal_Div_Salida();
  Cal_PLL();
}

void Cal_PLL() {
  
byte TEMPRefDBR;
byte TEMPrdiv2DBR;

if (_RefDBR==0){
  TEMPRefDBR= 1;
}
else {
   TEMPRefDBR= 2;
}
if (_rdiv2DBR==0){
  TEMPrdiv2DBR=1;
}
else {
   TEMPrdiv2DBR= 2;
}

PFDFreq  = (_FreqRef * TEMPRefDBR) / TEMPrdiv2DBR / _RCount;//0.1Mhz
           
float N=0;
  if (_feedbackType==1)
  {
     N = (RFout * ouputdivid) / PFDFreq;
   }
  else
  {
      N = (RFout / PFDFreq);
  }

_INT = N;

//unsigned int MOD = ((1000*(PFDFreq/ PasoCanal)));
unsigned int MOD = ((PFDFreq / PasoCanal));



unsigned long Ntemp= N*100;
unsigned long INTTemp=_INT*100;
unsigned long temp= Ntemp-INTTemp; //N - INT


//float FRACT = (((float) N - (float)INT)*(float)MOD);
unsigned long FRACT =(temp * MOD)/100;

unsigned int FRAC = FRACT;


//int GCDT= gcd(MOD, FRAC);

//_MOD=MOD/GCDT;
//_FRAC=FRAC/GCDT;
if (MOD == 1){
    MOD = 2;
}            
_MOD=MOD;
_FRAC=FRAC;

}


void Cal_Div_Salida() {
//****************************************************
//Calculo de Factor de divicion de la salida
if (RFout >= 2200000)
  {
  _Rfdivider =0 ; // Salida Dividido=1
  ouputdivid=1;
  }
  else if (RFout < 68750)
  {
  _Rfdivider =6 ; // Salida Dividido=64
  ouputdivid=64;
  }
  else if (RFout < 137500)
  {
  _Rfdivider =5 ; // Salida Dividido=32
  ouputdivid=32;
  }
  else if (RFout < 275000)
  {
  _Rfdivider =4 ; // Salida Dividido=16
  ouputdivid=16;
  }
else if (RFout < 550000)
  {
  _Rfdivider =3 ; // Salida Dividido=8
  ouputdivid=8;
  }
else if (RFout < 1100000)
  {
  _Rfdivider =2 ; // Salida Dividido=4
  ouputdivid=4;
  }    
else if (RFout < 2200000)
  {
  _Rfdivider =1 ; // Salida Dividido=2
  ouputdivid=2;
  }
 }
//*****************************************************

Por la pruebas que e echo párese que anda