Creo que Lo estas pensando mostrar en 5 displays por lo que parece (ya que queres 2 digitos despues de la coma)... entonces.... porque complicarse con flotantes? Porque no usar enteros con un poquito de error tal ves ?
En ves de dividirlo... Solo multipliquemos y dividamos rotando....
Con esto lo logras (cualquiera de los 2):
ResultadoEntero = (lecturaADC*29) + ((lecturaADC*19)>>6); //o
ResultadoEntero = (lecturaADC*30) - ((lecturaADC*45)>>6);
Obviamente esto te va a dar un resultado donde los 5 digitos enteros sean tus valores. Los 3 primeros tus digitos son los de ANTES de la coma, y los 2 que le siguen los que estan despues de la coma.
Algunos valores:
Tu formula = lecturaADC *300 /1024
(Aclaro que modifique el 1023 por 1024 ya que me permite simplificar el numero)
ADC Tuformula MiFormulaResta MiFormulaSuma
1 0.2929 30 29
10 2.929 293 292
100 29.296 2930 2929
500 146.484 14649 14648
1023 299.707 29971 29970Pasarlo a BCD deberia ser muy sencillo teniendo esto ya. El algoritmo de BCD si tu problema es el espacio, no lo hagas con divisiones, hacelo con sucesivas restas, y va a ocupar mucho menos. Y observa que con trabajar con numeros enteros de 16 bits sin signo es suficiente incluso al multiplicarlos. 4 for y estaria realizado
Algo asi:
entero = Valor que te dio la formula anterior;
for(decmil=0;entero>=10000; entero-=10000, decmil++);
for(mil=0;entero>=1000; entero-=1000, mil++);
for(cien=0;entero>=100; entero-=100, cien++);
for(diez=0;entero>=10; entero-=10, diez++);
unidad = entero;
Me ocupa 191(suma)/196(resta) words en un PIC16 (19% de PIC16F84A que posee 1.75KB), un programita con solo eso, si el tuyo posee 7KB entonces deberia ocupar un 5%.... dependiendo del PIC es el tamaño que va a quedar. Sino la simple es cambiar el micro, si ya tenes problemas con esta cantidad de codigo.
--------------------------------------------------
Por si te interesa en como llegue a esos numeros de arriba, fue asi...
Tu idea es que te de un numero con 2 lugares luego de la coma y 3 antes, por lo tanto yo no quiero la coma, entonces debo multiplicarlo por 100.
Pero es lo mismo que si antes hacia:
\frac{lectura*300*100}{1024} = \frac{lectura*30000}{1024}
Pero.... observo que 30000 / 1024 es 29 con algo... por lo tanto puedo tomar 2 formas de realizarlo..... Ir por el 30 o por el 29
Si voy por el 30, me queda que 1024 * 30 = 30720, por lo que me quedan 720
\frac{lectura*(30720 - 720)}{1024} = \frac{lectura*30720}{1024}-\frac{lectura*720}{1024}
Pero simplificando....
\frac{lectura*720}{1024} = \frac{lectura*45}{64}
Me queda:
lectura*30-\frac{lectura*45}{64}
La otra forma es ir por el 29 y sumar... 29*1024= 29696 por lo que me falta 304
\frac{lectura*(29696 + 304)}{1024} = \frac{lectura*29696}{1024}+\frac{lectura*304}{1024}
Simplificando..
\frac{lectura*304}{1024} = \frac{lectura*19}{64}
Me queda...
lectura*29 + \frac{lectura*19}{64}
Codigo Final:
entero = (lecturaADC*29) + ((lecturaADC*19)>>6);
for(decmil=0;entero>=10000; entero-=10000, decmil++);
for(mil=0;entero>=1000; entero-=1000, mil++);
for(cien=0;entero>=100; entero-=100, cien++);
for(diez=0;entero>=10; entero-=10, diez++);
unidad = entero;
PD: Observaras que al tener 1024 en la formula, ese es el error que comentaba, ya no vas a tener mas 300.00 como maximo sino 299.70, pero va a ser 0 si es que la lectura es 0.
Es decir el error va creciendo a medida que el la lectura llega a 1023, donde es maximo y es de 0.3 (0.29 para la resta), se podria reducir el error a costa de mas codigo aunque no parece tener demasiado sentido. PERO si queres que se reduzca, se puede hacer un pequeño cambio en el codigo y reducir el error a 0.1. Y no vamos a dividir el algoritmo de BCD
Maximo error en los valores 340,681 y 1022, donde el error es de 0.1 aproximadamente. Pero tu inicio es 00000, y tu final es 30000 si o si. (Recorda que tenes la coma 2 lugares desde el digito mas a la derecha)
for(decmil=0;lecturaADC>=341; lecturaADC-=341, decmil++);
entero = (lecturaADC*29) + ((lecturaADC*19)>>6);
for(mil=0;entero>=1000; entero-=1000, mil++);
for(cien=0;entero>=100; entero-=100, cien++);
for(diez=0;entero>=10; entero-=10, diez++);
unidad = entero;
PD2: Crear una multiplicación con sumas sucesivas genera muy poca ganancia de espacio, y es una perdida de tiempo.
