Escribir digitos menos significativos en LCD con CCS

[Braulio]

Amigos de TodoPic:

Tengo el siguiente problema: Vengo programando en C con CCS y necesito escribir en un LCD un dato que esta en un registro de 4 bytes (int32), el cual sería un dato de 10 dígitos en decimal, pero de los cuales solo deseo escribir los 9 dígitos menos significativos y obviar el dígito mas significativo. Por ejemplo... de tener en el registro el número 2 400 000 000, deseo que se escriba en el LCD solo 400 000 000.

Actualmente lo que hago es escribir con la función PRINTF, los 10 dígitos y luego borrar el dígito más significativo, pero resulta que cuando el dato se actualiza constantemente aparece el dígito no deseado de una manera "tenue" "titilante" y hasta "fantasmagórica" lo cual obviamente es por escribirlo y borrarlo de forma veloz y continua... Además que voy a necesitar ese espacio para colocar otro caracter después...

Ojala alguien tenga una mejor idea que la mía para resolver este problema, lo ideal sería nunca escribir ese dígito. Agradeceré mucho cualquier ayuda. Salu2.

BRAULIO

[darck_khronos]

No se te ah ocurrido poner printf(lcd_putc,"%9Lu",variable)

[cristian_elect]

Solo de numeros de 10 digitos. sin signo.

[migsantiago]

Hola. Arma la cadena a mandar a la LCD mediante sprintf(). Luego sustituyes los caracteres que no te sirven de forma manual, reemplazándolos por "espacios". Al final mandas con printf la cadena modificada.

[Nocturno]

¿Puedes operar con int32?

Si la respuesta es afirmativa, quizás podrías hacer lo siguiente:

variable % (int32)1000000000

[Braulio]

¡Gracias a todos por sus respuestas!

La solución finalmente fue lo que me indicó MigSantiago... yo desconocía el uso de "sprintf"... ahora es mucho mas sencillo hacer cualquier modificación a lo que uno imprime en el LCD... ¡Muchas gracias MigSantiago!.

Lo que hice fue lo siguiente, tal como me recomendaron, armé la cadena en un arreglo aparte para 10 caracteres (11 bytes, incluyendo NULL que va al final de toda cadena) y en lugar de borrar el dígito no deseado,  pase uno a uno solo los dígitos deseados a otro arreglo pero de 9 caracteres (10 bytes) y ese es el que mandé imprimir, cosa que así ya no se toca nunca el espacio del décimo dígito en el LCD, que yo lo necesito para escribir otra cosa... quedó perfecto...
¡¡DESAPARECIÓ EL FANTASMA!! 

Este es el código usado.

Código: [Seleccionar]


int32 dato;
int8  cadena_10[11];
int8  cadena_9[10];
sprintf(cadena_10,"%010Lu",dato);
for(c1=0; c1<9; c1++) cadena_9[c1]=cadena_10[c1+1];
lcd_gotoxy(8,1);
printf(lcd_putc,"%09s", cadena_9);


El índice c1+1 es porque simulando en Proteus "descubrí" que el dígito mas significativo lo guarda la en la posición 0.. por ejemplo, si:

dato = 2 400 000 000;

Luego de: sprintf(cadena_10,"%010Lu",dato);

El arreglo cadena_10 queda así.

cadena_10[0]  = 2
cadena_10[1]  = 4
cadena_10[2]  = 0
cadena_10[3]  = 0
cadena_10[4]  = 0
cadena_10[5]  = 0
cadena_10[6]  = 0
cadena_10[7]  = 0
cadena_10[8]  = 0
cadena_10[9]  = 0
cadena_10[10]= NULL

De los cuales yo solo rescato para imprimir desde "cadena_dato_10[1]" hasta "cadena_10[10]"

A Darck_khronos: Probé, pero resulta que al usar la instrucción

Código: [Seleccionar]

printf(lcd_putc,"%9Lu",variable)
el CCS imprime los 9 bits mas significativos en el LCD (como era de esperarse), pero para mi caso lo que yo necesitaba eran los menos significativos


A Cristian_elect: Si, un dato int32 puede albergar desde 0 hasta 4 294 967 295 (10 dígitos)


A Nocturno: Si, normalmente opero con el dato int32 sumas y restas.. pero esa operación no la conozco muy bien...

Código: [Seleccionar]

variable % (int32)1000000000
¿creo que tiene que ver con el residuo verdad? ¿para que va el (int32) entre paréntesis?


Una vez mas amigos:

MUCHAS GRACIAS POR VUESTRAS RESPUESTAS.

Salu2 a to2

BRAULIO

[Nocturno]

Exacto, es el resto o resíduo de la división.
Lo que he puesto entre paréntesis está para asegurarme que el compilador interpreta esa constante como un número de tipo int32. Es un casting.

[bigluis]

Exacto, es el resto o resíduo de la división.
Lo que he puesto entre paréntesis está para asegurarme que el compilador interpreta esa constante como un número de tipo int32. Es un casting.

  Tengo entendido que al utilizar la funcion de resto o residuo, el compilador genera demasiado codigo, por lo cual no la considero muy conveniente.

Corrijaname si me equivoco.

[Nocturno]

Pues no sé cuánto genera, pero el printf también es un buen tragón. Habría que compilarla para poder compararlas.

[bigluis]

Tambien he observado que puedes hacer lo siguiente:

Código: [Seleccionar]

int32 dato;
int8  cadena_10[11];
lcd_gotoxy(2,1);
sprintf(cadena_10,"%010Lu",dato);
printf(lcd_putc,"\n%09s",cadena_10+1);

Con esto te ahorrarías las líneas del for y la cadena_9.

[bigluis]

Pues no sé cuánto genera, pero el printf también es un buen tragón. Habría que compilarla para poder compararlas.

He revisado, y solamente se generan poco más de 100 instrucciones en assambler. Pero seguramente estas instrucciones forman parte de un ciclo para que se realice la operacion de residuo, es decir unos cuantos milisegundos de programa.

Si no se necesita que el programa opera a gran velocidad puede ser facilmente obviado.

[Nocturno]

Me ha picado la curiosidad y he probado ambos métodos.

Con este:

Código: C

1. int32 dato;
2.         int8  cadena_10[11];
3.         int8  cadena_9[10];
4.         int8 c1;
5.        
6.         sprintf(cadena_10,"%010Lu",dato);
7.         for(c1=0; c1<9; c1++) cadena_9[c1]=cadena_10[c1+1];
8.        
9.         while (1);

tenemos un consumo de memoria de programa de 418 bytes y una ejecución de 19937 ciclos.

Con este otro:

Código: C

1. unsigned int32 dato,variable;
2.  
3.         variable = 1234567890;
4.         variable = dato % (unsigned int32)1000000000;
5.        
6.         while (1);

tenemos un consumo de memoria de programa de 190 bytes y una ejecución de 748 ciclos.

Para las pruebas he usado CCS y un PIC18F8722

[bigluis]

  Acabo de probar de nuevo y estaba completamente equivocado.

Me dio los siguientes resultados

Código: [Seleccionar]

int32 dato;
void main(){
   dato=1234567890;
   lcd_init();
   printf(lcd_putc,"%9Lu", dato%1000000000);
}

               ROM used: 440 words (5%)
                         Largest free fragment is 2048
               RAM used: 13 (4%) at main() level
                         38 (10%) worst case
               Stack:    3 locations

Y para el otro caso

Código: [Seleccionar]

int32 dato;
int8  cadena_10[11];
void main(){
   dato=1234567890;
   lcd_init();
   sprintf(cadena_10,"%10Lu",dato);
   printf(lcd_putc,"%9s",cadena_10+1);
}

               ROM used: 457 words (6%)
                         Largest free fragment is 2048
               RAM used: 22 (6%) at main() level
                         47 (13%) worst case
               Stack:    3 locations

En mi caso para las pruebas he utilizado CCS y un PIC16F887

Supongo que en el PIC18Fxxxx se ahorran mas lineas de codigo debido a que tiene el modulo multiplicador integrado.