Punto flotante en LCD

Alguien sabe como enviar un numero punto flotante a una LCD ej. 23.45? estoy programando en C...

En C es muy sencillo:

Código: Seleccionar todo

printf(lcd_caracter,"Valor flotante = %f",valor);

Desde luego “valor” debe ser una variable de tipo flotante y tener asignado el valor que quieres mostrar, “lcd_caracter” es la función que imprime en el LCD (obvio, jajaja), el nombre variara para cada quien. Cualquier cosa comentala .

Saludos,

Saludos, soy nuevo en el foro y tengo el mismo problema, uso CCS, la diferencia es que escribo lcd_putc para enviar a la pantalla y no se como limito el numero de decimales que se muestran en la pantalla? Alguien puede decirme.

que mas jaisser?

yo por lo general usaba librerias creadas por mi para envio de datos al lcd, lcd_putc no se si envia un caracter por caracter o si toda la cadena... ahi es donde esta el punto, sea lo que sea, envia es una cadena, asi que su valor de coma flotante deben convertirlo en una cadena, algo como ftoa (float to ascii), si la encuentran usenla, la convierten y la envian al lcd, asi es como funciona...cualquier cosa me comenta... cuidensen...

Esta rutina convierte un 'int' sin signo hasta 999, en una cadena de hasta 3 dígitos decimales
que se puede mandar a un LCD en modo texto.

Código: Seleccionar todo


char *hex2dec(unsigned HEX)
{
char U, D, C, M, CH[4], NZ;

strcpy(CH,"***");
NZ=0; // Asume como el puntero al primer dígito no nulo

if (HEX <= 999)
  {

  C =  HEX/100;  // Digito de las centenas
  D = (HEX - C*100) /10;   // Digito de las decenas
  U = (HEX - C*100 - D*10);   // Digito de las unidades

  CH[0] = 48+C;  //48 es el código del "0"
  CH[1] = 48+D;
  CH[2] = 48+U;
  CH[3] = 0;

  if (C==0) // Para que no ponga ceros a la izquierda
    {
    CH[0] = 32;   //32 es el código del " "
    //NZ=1; // para recostar a izquierda (*)
    if (D==0)
      {
      CH[1] = 32;
      //NZ=2; // para recostar a izquierda (*)
      }
    }
  }
return &CH[NZ];
}
// * Descomentariarlas si se quiere recostar a izquierda (devuelve el puntero al primer dígito no nulo)


Para ampliar a todo el rango de 'int' (0-65535) se debería agrandar el string a 6 caracteres
(5 dígitos más el fin de cadena), y agregar dos variables (unidades y decenas de mil).

Código: Seleccionar todo


char *hex2dec(unsigned HEX)
{
char U, D, C, M, N, CH[6],NZ;

strcpy(CH,"*****");
NZ=0; // Asume como el puntero al primer dígito no nulo

 // Digito de las decenas de mil
  N =  HEX/10000; 

  // Digito de las unidades de mil
  M = HEX/1000  - N*10;   

  // Digito de las centenas
  C = HEX/100    - M*10  -  N*100;

 // Digito de las decenas
  D = HEX/10      - C*10  -  M*100  -  N*1000;   

 // Digito de las unidades
  U = HEX            - D*10  - C*100  - M*1000  - N*10000;   

  CH[0] = 48+N;  //48 es el código del "0"
  CH[1] = 48+M;
  CH[2] = 48+C;
  CH[3] = 48+D;
  CH[4] = 48+U;
  CH[5] = 0;

  if (N==0) // Para que no ponga ceros a la izquierda
    {
    CH[0] = 32;   //32 es el código del " "
    //NZ=1; // para recostar a izquierda (*)
    if (M==0)
      {
      CH[1] = 32;
      //NZ=2; // para recostar a izquierda (*)
      if (C==0)
        {
        CH[2] = 32;
        //NZ=3; // para recostar a izquierda (*)
        if (D==0)
          {
          CH[3] = 32;
          //NZ=4; // para recostar a izquierda (*)
          }
        }
      }
    }

return &CH[NZ];
}
// * Descomentariarlas si se quiere recostar a izquierda (devuelve el puntero al primer dígito no nulo)


El paso a decimal no lo pensé, pero con este algoritmo en mente no debería ser muy difícil.
En todo caso, falta detectar en que momento se guarda el punto.

Por favor, si le encuentran errores me avisan.
Gracias.

hola a todos,

buen aporte alejandro, yo hice un ftoa para c++ de pc, en visual studio, el que quiera ver un ejemplo aqui esta:
http://leonardojaimes.idoo.com/info/vs2005-8/rutinas.html
este es un ejemplo, tocaria convertirlo a c para pics... pero la idea es esa, cuidensen... me comentan cualquier cosa

Gracias, me viene bárbaro para VB.

Listo: Ya la controlé hasta 999.999 y no hay problemas. Creo que ya está lista.
El que le encuentre un bug por favor me avisa.

VERSIÓN FINAL

NOTA: Por defecto
los 'char' son 'unsigned'
los 'int' son 'signed'
los 'unsigned' son 'int'

Rutina principal

Código: Seleccionar todo


//==============================================================
// Convierte VALOR en un CHAR[8] de hasta 6 digitos (más el punto y el cero final)
//
char *DESCOMP(float VALOR)
    {
    unsigned ENTE, DECI;
    char CHENTE[4], CHDECI[4];
    float BUFFER;

    // Separación de parte entera y decimales
    ENTE = VALOR;        // Retiene la parte entera
    BUFFER = ENTE;
    DECI = 1000. * (VALOR - BUFFER); // Retiene los primeros 3 dígitos de la parte decimal

    // Armado de cada cadena por separado
    strcpy(CHENTE,sprint(ENTE,0)); // Pone blancos a izquierda
    strcpy(CHDECI,sprint(DECI,1)); // Pone ceros a izquierda

    // Encadenado final
    strcpy(TXT,CHENTE); // Copia los 3 primeros digitos
    strcat(TXT,".");          // Pome el punto
    strcat(TXT,CHDECI);  // Agrega los 3 dígitos decimales siguientes

    return TXT;  // Formato: ABC.DEF, recostado a derecha
                       // Pone blancos a izquierda (A hasta B) y ceros a derecha.
    }


Esta rutina usa lo siguiente:

strcpy(OTRO, UN_STRING); copia UN_STRING en OTRO (de la biblioteca C)
strcat(OTRO, UN_STRING); copia UN_STRING al la cola de OTRO (de la biblioteca C)

A esta ya la conocen como hex2dec pero se le ha agregado el argumento ZEROSOK.
Además se limita a 3 digitos.

Código: Seleccionar todo


//==============================================================
// Guarda en un arreglo hasta 3 dígitos decimales de una variable 'int'
// Si ZEROSOK=0 Pone blancos a izquierda
// Si ZEROSOK=1 Pone ceros a izquierda
//
char *sprint(int HEXA, char ZEROSOK)
{
char NZ, CEN,DEC,UNI, CH[6];

  strcpy(CH,"***"); // Ocupa los 3 digitos
  NZ=0; // Puntero a devolver

  // Obtiene los decimales
  CEN = HEXA /100;
  DEC = (HEXA - 100 * CEN) /10;
  UNI =  HEXA  - 100 * CEN - 10 * DEC;

  CH[0] = 48 + CEN;   // Genera los caracteres ASCII
  CH[1] = 48 + DEC;  // 48 es el ASCII de "0"
  CH[2] = 48 + UNI;
  CH[3] = 0; //  y pone el fin de cadena

  if(!ZEROSOK) // Si ZEROSOK = 0, en lugar de ceros pone blancos a izquierda
  {
  if(CEN==0)
    {
    CH[0] = 32;  // 32 es el ASCII de " " (blanco)
    // NZ =1; // Descomentariar para recostar a izquierda
    if(DEC==0)
      {
      CH[1] = 32;
      // NZ =2; // Descomentariar para recostar a izquierda
      }
    }
  }
return (&CH[NZ]);
}


En la foto se ven borrosos los dígitos que están cambiando.

Las instrucciones del tipo "printf" admiten argumentos donde se especifica ese tipo de cosas:
Busca algo así

% [flags] [width] [.precision] [{ h | l | L }] conversion_type

en el ayuda de tu compilador que ahí va a estar bien explicado.
Saludos

gracias alejandro me ayudo mucho tu respuesta