Punto flotante en LCD

#1
Alguien sabe como enviar un numero punto flotante a una LCD ej. 23.45? estoy programando en C...
 
#2
En C es muy sencillo:

Código:
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,
 
#3
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.
 
#4
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...
 
#5
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:
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:
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.
 
#7
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:
//==============================================================
// 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:
//==============================================================
// 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.
 

Adjuntos

#8
jaiser dijo:
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.
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