contador lcd llega A 255 y se vuelve a 0 alguien que me de una mano

[kapotik]

Hola, estoy empezando con el lenguaje C, vengo del assembler, necesito hacerun contador LCD que cuente hasta 999999, pero cuando llega a 255 se vuelve a cero, uso una libreria para controlar el LCD que me pasaron, por favor alguien que me explique en que me estoy equivocando gracias.

Código: [Seleccionar]

#include <16f84a.h>
#use delay(clock=4000000)
#fuses xt,nowdt,noprotect
#byte portb=6
#include <lcdb.c>

int A=0;

void main(void)
{
lcd_init();                //Inicia LCD
lcd_putc(" Contador\n");   // Saca texto
lcd_putc(" Digital");      // Saca texto
delay_ms(2000);            // Retardo
lcd_putc("\f");            // Limpia pantalla
lcd_putc("Conteo\n");      //Saca texto

while(true)
{

if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++;            // Incremento el conteo
delay_ms(500);  // Para visualizar correctamente el conteo

if(A>=999999)      // Preguto si A es mayor o igual a 999999,
{               // cuando sea igual iguala "A" a cero
A=0;            



lcd_gotoxy(2,2);          //Acomoda cursor LCD
lcd_putc(" ");            //Limpia ese sector de pantalla
printf(lcd_putc,"%3U",A); // Imprime el conteo por la lcd
}
}
la libreria

Código: [Seleccionar]

///////////////////////////////////////////////////////////////////////////
//                                  
///////////////////////////////////////////////////////////////////////////
//     B0  
//     B1  
//     B2  E
//     B3  RS
//     B4  D4
//     B5  D5
//     B6  D6
//     B7  D7
//   (Sin 'RW')
//
// Funciones soportadas:
//                         lcd_init()
//                         lcd_gotoxy( BYTE col, BYTE fila)
//                         lcd_putc( char c)
//                              \f  Clear display                            
//                              \n  Go to start of second line                
//                              \b  Move back one position
//
///////////////////////////////////////////////////////////////////////////
#define use_portb_lcd TRUE  //LCD conectado al puerto b.
//
struct lcd_pin_map {
   BOOLEAN unused1; // RB0
   BOOLEAN unused2; // RB1
   BOOLEAN enable;  // RB2
   BOOLEAN rs;      // RB3
   int data : 4;    // RB4-RB7
} lcd;
//
#byte lcd = 0xF81  // Direccion de la estructura "lcd".
#byte lcd = 6      // Direccion del puerto B.
#define set_tris_lcd(x) set_tris_b(x)
#define lcd_type 2           // Tipo de LCD: 0=5x7, 1=5x10, 2=2 lineas
#define lcd_line_two 0x40    // Dirección de la LCD RAM para la 2da. linea
//
//Defino la cadena de inicializacion del LCD.
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
//
//Configuro el estado de cada pin para lectura y escritura:
struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // Escribir.
struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // Leer.
//
//Funciones:
BYTE lcd_read_byte() {
      BYTE low,high;
      set_tris_lcd(LCD_READ);
      delay_cycles(1);
      lcd.enable = 1;
      delay_cycles(1);
      high = lcd.data;
      lcd.enable = 0;
      delay_cycles(1);
      lcd.enable = 1;
      delay_us(1);
      low = lcd.data;
      lcd.enable = 0;
      set_tris_lcd(LCD_WRITE);
      return( (high<<4) | low);
}
//
void lcd_send_nibble( BYTE n ) {
      lcd.data = n;
      delay_cycles(1);
      lcd.enable = 1;
      delay_us(2);
      lcd.enable = 0;
}
//
void lcd_send_byte( BYTE address, BYTE n ) {
      lcd.rs = 0;
      while ( bit_test(lcd_read_byte(),7) ) ;
      lcd.rs = address;
      delay_cycles(1);
      delay_cycles(1);
      lcd.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
}
//
void lcd_init() {
    BYTE i;
    set_tris_lcd(LCD_WRITE);
    lcd.rs = 0;
    lcd.enable = 0;
    delay_ms(15);
    for(i=1;i<=3;++i) {
       lcd_send_nibble(3);
       delay_ms(5);
    }
    lcd_send_nibble(2);
    for(i=0;i<=3;++i)
       lcd_send_byte(0,LCD_INIT_STRING[i]);
}
//
void lcd_gotoxy( BYTE x, BYTE y) {
   BYTE address;
   if(y!=1)
     address=lcd_line_two;
   else
     address=0;
     address+=x-1;
     lcd_send_byte(0,0x80|address);
}
//
void lcd_putc( char c) {
   switch (c) {
     case '\f'   : lcd_send_byte(0,1);
                   delay_ms(2);
                                           break;
     case '\n'   : lcd_gotoxy(1,2);        break;
     case '\b'   : lcd_send_byte(0,0x10);  break;
     default     : lcd_send_byte(1,c);     break;
   }
}


[AngelGris]

Hasta donde tengo entendido, las variables del tipo int, en CCS son de 8 bits; por lo tanto tu contador no podrá contar mas que 255

[MLO__]

Hola.

Tal como lo menciona el amigo AngelGris, solo llega a 255 por ser una variable de 8 bits. Si quieres que llegue a mas, prueba declarar tu variable del tipo long, o long long.

Saludos

[kapotik]

Hola.

Tal como lo menciona el amigo AngelGris, solo llega a 255 por ser una variable de 8 bits. Si quieres que llegue a mas, prueba declarar tu variable del tipo long, o long long.

Saludos

Gracias muchachos por las respuestas, probe con long y me da el error de que en la linea 36 el formato de impresion en el lcd no es valido, que seria esto: printf(lcd_putc,"%3U",A); // Imprime el conteo por la lcd

si le pongo long long compila pero sigue contando hasta 255

saludos

[planeta9999]

Además de lo que comentan los compañeros, lo raro es que te llegue hasta 255 usando una variable con signo (salvo que en CCS por omisión sea sin signo), que debería aceptar solo valores entre -128 y +128. Para almacenar un valor entre 0 y 255 tendría que ser "unsigned int".

Tendrás que usar una variable de 32 bits, para llegar hasta esos 999999.

[kapotik]

Además de lo que comentan los compañeros, lo raro es que te llegue hasta 255 usando una variable con signo (salvo que en CCS por omisión sea sin signo), que debería aceptar solo valores entre -128 y +128. Para almacenar un valor entre 0 y 255 tendría que ser "unsigned int".

Tendrás que usar una variable de 32 bits, para llegar hasta esos 999999.

buscando en la red encontre esto:
int (16 bits)
Utiliza generalmente 2 bytes de memoria, valores: de -32 768 a 32 767.
int (32 bits)
Utiliza generalmente 4 bytes de memoria, valores: de -2 147 483 648 a 2 147 483 647.

pero no entiendo como colocarlo ya que las dos se llaman igual.

[AcoranTf]

Tu problema es muy simple, estas inicializando la variable "A" como intEGER, por tanto el valor maximo de un integer es de 255.
Como no hay forma de crear una variable que abarque la cifra que tu quieres, deberas anidar dos contadores y hacer las operaciones correspondientes para controlarlo y sacarlo por el LCD. Te bastara con que una de las variables sea del tipo "long", que podra tener valores de hasta 65535 y la otra del tipo "int".
Por ejemplo supongamos las variables "long A=0; int B=1; C=0". C es el valor actual del contador, tendremos algo asi:  

Código: [Seleccionar]


long A=0;
int B=1
C=0

void main(void)
{
lcd_init();                //Inicia LCD
lcd_putc(" Contador\n");   // Saca texto
lcd_putc(" Digital");      // Saca texto
delay_ms(2000);            // Retardo
lcd_putc("\f");            // Limpia pantalla
lcd_putc("Conteo\n");      //Saca texto

while(true)
{

if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++;            // Incremento el conteo
delay_ms(500);  // Para visualizar correctamente el conteo

if(A==65535)   // Cada vez que rebase el valor de A
{ B++;}            // Incrementa B
C= A&B;          // Ajusta el contador al producto de A por B

if(C>=999999)      // Preguto si C es mayor o igual a 999999,
{                         // cuando sea igual iguala "A" a cero, "B" igual a 1 y "C" igual a 0
A=0;  
B=1;
C=0;                    // El resto sigue aqui.


Saludos.

[kapotik]

Tu problema es muy simple, estas inicializando la variable "A" como intEGER, por tanto el valor maximo de un integer es de 255.
Como no hay forma de crear una variable que abarque la cifra que tu quieres, deberas anidar dos contadores y hacer las operaciones correspondientes para controlarlo y sacarlo por el LCD. Te bastara con que una de las variables sea del tipo "long", que podra tener valores de hasta 65535 y la otra del tipo "int".
Por ejemplo supongamos las variables "long A=0; int B=1; C=0". C es el valor actual del contador, tendremos algo asi:  

Código: [Seleccionar]


long A=0;
int B=1
C=0

void main(void)
{
lcd_init();                //Inicia LCD
lcd_putc(" Contador\n");   // Saca texto
lcd_putc(" Digital");      // Saca texto
delay_ms(2000);            // Retardo
lcd_putc("\f");            // Limpia pantalla
lcd_putc("Conteo\n");      //Saca texto

while(true)
{

if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++;            // Incremento el conteo
delay_ms(500);  // Para visualizar correctamente el conteo

if(A==65535)   // Cada vez que rebase el valor de A
{ B++;}            // Incrementa B
C= A&B;          // Ajusta el contador al producto de A por B

if(C>=999999)      // Preguto si C es mayor o igual a 999999,
{                         // cuando sea igual iguala "A" a cero, "B" igual a 1 y "C" igual a 0
A=0;  
B=1;
C=0;                    // El resto sigue aqui.


Saludos.

gracias por la explicacion, pero como declaro a C en el inicio?, recorda que soy muy novatillo en este lenguaje y hay muchas cosas que alo mejor ustedes dan por entendido y yo trato, pero todavia estoy aprendiendo.

saldos

[MLO__]

Hola

Al utilizar long, debes cambiar la forma en la que se escribe el dato en la LCD con la funcion printf .... si mal no recuerdo es %lu  ....

Saludos

[planeta9999]

buscando en la red encontre esto:
int (16 bits)
Utiliza generalmente 2 bytes de memoria, valores: de -32 768 a 32 767.
int (32 bits)
Utiliza generalmente 4 bytes de memoria, valores: de -2 147 483 648 a 2 147 483 647.

pero no entiendo como colocarlo ya que las dos se llaman igual.

Deberías de consultar el manual del compilador que estés usando, para ver que tipo de variables puedes definir.
Yo hace años que solo uso micros de 32 bits y compiladores de Microchip, lo ideal sería que pudieras declarar una variable de tipo "long long" que te permitiría disponer de 32 bits.

Si tu compilador es el CCS, tal vez sea algo así:
http://www.aquihayapuntes.com/programacion-pic-en-c.html?start=4

[RALF2]

Que tal amigos.
Kapotik, se me ocurre para resolver tu problema hacer lo siguiente:
int a,b,c;
donde a es el byte menos significativo y c el byte mas significativo.
Luego:
si a>99 incremento b y hago a=0
asi sucesivamente hasta que b>99 entonces incremento c y hago a=0 y b=0.
luego cuando c==99 hago, printf("%u%2u%2u",c,b,a);

pruebalo a ver que tal  

[kapotik]

Hola

Al utilizar long, debes cambiar la forma en la que se escribe el dato en la LCD con la funcion printf .... si mal no recuerdo es %lu  ....

Saludos

bueno, empieza a tener forma, gracias a todos por la ayuda, la clave fue este mensaje que cito, la manera del printf y logicamente el "long long", puedo contar hasta numeros de 10 digitos, mas o menos hasta 4652897356, no recuerdo bien el numero pero empesaba con 4, pero...........y siempre tiene que haber un pero, es que no me vuelve a cero, si no que empieza a contar de manera extraña, calculo yo que debe de seguir incrementando pero en algun modo raro, hexadecimal o algo por el estilo.

les pongo el codigo como quedo, para ver si alguien se da cuenta porque no me vuelve a cero.

Código: [Seleccionar]

#include <16f84a.h>
#use delay(clock=4000000)
#fuses xt,nowdt,noprotect
#byte portb=6
#include <lcdb.c>

long long A=0;

void main(void)
{
lcd_init();                //Inicia LCD
lcd_putc(" Contador\n");   // Saca texto
lcd_putc(" Digital");      // Saca texto
delay_ms(2000);            // Retardo
lcd_putc("\f");            // Limpia pantalla
lcd_putc("Conteo\n");      //Saca texto

while(true)
{

if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++;            // Incremento el conteo
delay_ms(10);  // Para visualizar correctamente el conteo

if(A>=999999)      // Preguto si A es mayor o igual a 255,
{               // cuando sea igual iguala "A" a cero
A=0;             
}
}



lcd_gotoxy(2,2);          //Acomoda cursor LCD
lcd_putc(" ");            //Limpia ese sector de pantalla
printf(lcd_putc,"%lu",A); // Imprime el conteo por la lcd
}
}

[bmb]

Hola, en CCS puedes declarar variables de 32 bits directamente así:

Código: [Seleccionar]

int32 A=0;
El formato para printf es %Lu

Saludos!

Edit: con  estas instrucciones:

Código: [Seleccionar]

lcd_gotoxy(2,2);          //Acomoda cursor LCD
lcd_putc(" ");            //Limpia ese sector de pantalla
Solo borras un carácter de la línea donde debe aparecer el valor de A y por eso es posible que veas números extraños.  Lo mejor es que borres la línea completa o como mínimo los 6 caracteres que ocupan el valor máximo que alcanza la variable A.

Saludos!

[kapotik]

Hola, en CCS puedes declarar variables de 32 bits directamente así:

Código: [Seleccionar]

int32 A=0;
El formato para printf es %Lu

Saludos!

Edit: con  estas instrucciones:

Código: [Seleccionar]

lcd_gotoxy(2,2);          //Acomoda cursor LCD
lcd_putc(" ");            //Limpia ese sector de pantalla
Solo borras un carácter de la línea donde debe aparecer el valor de A y por eso es posible que veas números extraños.  Lo mejor es que borres la línea completa o como mínimo los 6 caracteres que ocupan el valor máximo que alcanza la variable A.

Saludos!

como borro la segunda linea porque solo se borrar toda la pantalla con:
 lcd_putc("\f");

[AngelGris]

Para borrar la segunda línea se puede recurrir a un gotoxy, que coloque el cursor en el primer caracter de la segunda línea. Luego un printf con todos espacios en blanco.