¿Cómo dividir un número de punto flotante en dígitos individuales?

Hay muchas maneras de hacerlo. Puede encontrar que su compilador tiene una función de biblioteca para hacerlo por usted. Puede ser posible con:

• sprintf () / snprintf ()
• dtostrf ()
• dtoa ()

Alternativamente, no es demasiado difícil escribir tu propia rutina para hacerlo. Es solo el caso de calcular primero cuántos dígitos hay antes del punto decimal, dividiéndolo por 10 tantas veces, luego tomar la parte entera repetidamente mientras se multiplica por 10, asegurándose de agregar el punto decimal en el lugar correcto.

Por lo tanto, en el pseudocódigo puede verse algo así como:

If the value < 0.0:
    Insert - into string
    Subtract value from 0.0 to make it positive.
While the value <= 10.0:
    Divide by 10
    Increment decimal counter
For each digit of required precision:
    Take the integer portion of the value and place it in the string
    Subtract the integer portion from the value
    Decrement decimal counter
    If decimal counter is 0:
        Insert decimal point
    Multiply the value by 10.

Utilice sprintf (). Funciona igual que printf (), pero "imprime" en una cadena (también conocida como matriz de caracteres).

haz: char stringvar [10]; sprintf (stringvar, "% 9.4f", floatvar);

En una MCU pequeña sin soporte de punto flotante de hardware, deberíamos hacer la matemática de punto flotante tan pequeña como sea posible, y, a menos que realmente necesites la familia de funciones de printf, intenta evitarla porque aumenta y reduce la velocidad del código.

Sugiero convertir el flotador en un entero multiplicando primero el flotante por 1,000.0 (suponiendo que quieres tres lugares decimales) y luego convertirlo en un entero largo, redondear según corresponda. Si va a mostrar el resultado en una pantalla LCD de 7 segmentos o matriz de puntos, creo que este formato es ideal.

Supongamos que el flotador puede estar en el rango de 0 a 999.999 (negar si es negativo, guardar el signo para mostrarlo más adelante). El int largo correspondiente tiene el rango de 0 a 999999. Convertiremos el número comenzando con el más significativo dígito.

Pseudo código:

dig6 = -1  // Init MSDigit
while number >= 0
   number = number - 100,000
   dig6 = dig6 + 1
number = number + 100,000  // Restore number, Dig 6 is done

dig5 = -1
while number >= 0
   number = number - 10,000
   dig5 = dig5 + 1
number = number + 10,000 // number can be switched to 16-bit here for speed

... dig4 and 3 in similar fashion

dig2 = -1
while number >= 0
   number = number - 10
   dig2 = dig2 + 1
dig1 = number + 10

En este punto, tiene los seis dígitos almacenados en un byte cada uno y el signo menos guardado. Si está utilizando una pantalla LCD de 7 segmentos, pase los dígitos a una función de codificador de 7 segmentos antes de escribir en la pantalla LCD. Si está utilizando una pantalla de matriz de puntos con interfaz en serie, agregue 0x30 a cada dígito para la codificación ASCII. También debemos recordar el punto decimal entre dig4 y dig3.

Este algoritmo es bastante rápido ya que no hay multiplicación y división involucradas. Lo he usado en pequeñas MCU de 4 bits con buenos resultados.