#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
}
}///////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////
// 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;
}
}
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
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.
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.
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.
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.
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
#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
}
}
int32 A=0;lcd_gotoxy(2,2); //Acomoda cursor LCD
lcd_putc(" "); //Limpia ese sector de pantallaHola, 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!
lcd_gotoxy(2,1); // Al inicio de la segunda línea del LCD
lcd_putc(" "); // Imprime 16 espacios en blanco en el LCDlcd_gotoxy(2,1); // Ubicar cursor en la columna 1 de la segunda línea del LCD
printf(lcd_putc, "Valor: %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)lcd_gotoxy(2,1); // Ubicar cursor en la columna 1 de la segunda línea del LCD
printf(lcd_putc, "Valor: %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)#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
A = read_eeprom(0x00); //Lee contador de la EEPROM
if (A > 9)
A= 0x00; //Ajusta el contador si es mayor de 9
while(true)
{
if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
delay_ms(1); // Para visualizar correctamente el conteo
if(A>=9999999) // Preguto si A es mayor o igual a 255,
{ // cuando sea igual iguala "A" a cero
A=0;
}
}
lcd_gotoxy(1,2); //Acomoda cursor LCD
printf(lcd_putc, "VALOR: %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)
write_eeprom(0x00,A); //Lo salva en la EEPROM
}
}Correccion, si guarda en la eprom, pero solo hsta el 9, a partir del 10 ya no lo guarda,que sera?
Saludos
#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
A = read_eeprom(0x00); //Lee contador de la EEPROM
while(true)
{
if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
delay_ms(1); // Para visualizar correctamente el conteo
if(A>=9999999) // Preguto si A es mayor o igual a 255,
{ // cuando sea igual iguala "A" a cero
A=0;
}
}
lcd_gotoxy(1,2); //Acomoda cursor LCD
printf(lcd_putc, "FICHAS: %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)
write_eeprom(0x00,A); //Lo salva en la EEPROM
}
}#include <internal_eeprom.c>No puedes guardar un campo de 32 bits, en una dirección de memoria de un microcontrolador de 8bits.
Echale un vistazo a este post, que te lo aclara muy bien, con el uso de make8 y make32:
https://www.ccsinfo.com/forum/viewtopic.php?p=15000
No puedes guardar un campo de 32 bits, en una dirección de memoria de un microcontrolador de 8bits.
Echale un vistazo a este post, que te lo aclara muy bien, con el uso de make8 y make32:
https://www.ccsinfo.com/forum/viewtopic.php?p=15000
Hola planeta9999, el hilo al que haces referencia es del año 2002! En la nuevas versiones de CCS se puede hacer usando la librería que menciono en el post anterior.
Saludos!
#include <internal_eeprom.c>
Normalmente cuando grabas un PIC, todas las posiciones de memoria que no se utilizan se quedan con 0xFF (255 en decimal), comprueba las cuatro direcciones de la eeprom, y si las tienes con 0xFF, inicialízalas a 0x00.
Normalmente cuando grabas un PIC, todas las posiciones de memoria que no se utilizan se quedan con 0xFF (255 en decimal), comprueba las cuatro direcciones de la eeprom, y si las tienes con 0xFF, inicialízalas a 0x00.
pero si la inicializo a 0x00 no voy a perder la cuenta cada ves que vuelva a conectar la tension?
... cuando lo inicio por primera ves, el contador arranca en un valor, el mas alto de la cuenta ...
... cuando lo inicio por primera ves, el contador arranca en un valor, el mas alto de la cuenta ...
Hola kapotik, me alegra que tu programa esté progresando. No te entiendo muy bien lo que quieres decir. Tal vez si pones el código podamos ver de que se trata.
Saludos!
#include <16f84a.h>
#use delay(clock=4000000)
#fuses xt,nowdt,noprotect
#byte portb=6
#include <lcdb.c>
#include <internal_eeprom.c>
int32 A = 0;
void main(void)
{
lcd_init(); //Inicia LCD
lcd_putc(" Inicializando\n"); // Saca texto
lcd_putc("El Equipo Aguarde"); // Saca texto
delay_ms(5000); // Retardo
lcd_putc("\f"); // Limpia pantalla
lcd_putc("kapotik.\n"); //Saca texto
A = read_int32_eeprom(0x04); //Lee contador de la EEPROM
while(true)
{
if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
delay_ms(1); // Para visualizar correctamente el conteo
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
}
lcd_gotoxy(1,2); //Acomoda cursor LCD
printf(lcd_putc, "valor %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)
write_int32_eeprom(0x04, A);
}
}
#rom 0x00={4,3,2,1}#rom 0x00={0,0,0,0,0,0,0,0}#include <16f84a.h>
#use delay(clock=4000000)
#fuses xt,nowdt,noprotect
#byte portb=6
#rom 0x04 ={0,0,0,0,0,0,0,0}
#include <lcdb.c>
#include <internal_eeprom.c>
int32 A = 0;
void main(void)
{
lcd_init(); //Inicia LCD
lcd_putc(" Inicializando\n"); // Saca texto
lcd_putc("El Equipo Aguarde"); // Saca texto
delay_ms(5000); // Retardo
lcd_putc("\f"); // Limpia pantalla
lcd_putc("kapotik.\n"); //Saca texto
A = read_int32_eeprom(0x04); //Lee contador de la EEPROM
while(true)
{
if(input(pin_A0)==0) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
delay_ms(1); // Para visualizar correctamente el conteo
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
}
lcd_gotoxy(1,2); //Acomoda cursor LCD
printf(lcd_putc, "valor %Lu ", A); // Imprime 16 espacios en el LCD (Los caracteres de %Lu no se cuentan)
write_int32_eeprom(0x04, A);
}
}#rom 0x2100 = {0,0,0,0}write_int32_eeprom(0x00, A);Proteus no guarda nada en la EEPROM al apagar la simulación, o no se como hacerlo...
B = read_int32_eeprom(0x00);int32 A = 0, B = 0;hola bmb, simule el codigo y no me esta guardando el dato en la eeprom
pregunto, y hablo sin entender como lo estas usando, pero le colocaste una "B" al grabado de la eepromCódigo: [Seleccionar]B = read_int32_eeprom(0x00);
y cuando inicializa le estas diciendo que "B" es cero?Código: [Seleccionar]int32 A = 0, B = 0;
o yo lo estoy interpretando mal, por que sino en cada inicio pone a cero B, perdiendo el dato guardado
podrias explicarme como lo as usado
Saludos
Hola kapotik, hice lo que me explicaste, pero veo que es el Proteus el que no está haciendo nada con ese archivo, pues en ningún momento accede a el para escritura. Creo que esa opción que me diste es solo para tomar los datos iniciales de la EEPROM, pero nada más. Según la ayuda del VSM, al guardar la sesión se deberían guardar los datos de la EEPROM, pero en este caso no hace nada. Lo que hice entonces, fue utilizar la opción Debug del Proteus y al simular el programa paso a paso, puedo ver que graba muy bien los datos en la ventana de la EEPROM. Te adjunto nuevamente el programa con unas correcciones y el archivo de Proteus. Le adicione a la simulación un switch manual para poder activarlo sin salir del modo Debug.
Saludos!
Muy bien! Felicitaciones! Habrá que estudiar un poco más el Proteus, que seguramente tendrá su modo de hacerlo. Que grabador utilizas? Sería ideal que no tuvieras que sacar el PIC de la protoboard para grabarlo. Hay PICs que facilitan un poco más que el PIC16F84A la programación 'ICSP'
Saludos!
Felicitaciones !!
Hay una instrucción para el LCD que mueve el texto n posiciones a la izquierda o derecha.
Ya lo tratamos en varios lugares, si puedes hacer una búsqueda el el subforo de C, con scroll como clave, seguro encontraras lo que necesitas, sino avisa...
Me quede con la espina y te lo busque...
http://www.todopic.com.ar/foros/index.php?topic=5772.msg31490#msg31490 (http://www.todopic.com.ar/foros/index.php?topic=5772.msg31490#msg31490)
Hola kapotik, fíjate en este (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38916#msg38916), creo que es fácil ajustarlo para lo que necesitas.
Saludos!
#include <16f84a.h>
#fuses xt,nowdt,noprotect
#use delay(clock=4000000)
#rom 0x2100 ={0,0,0,0}
#define LCD_ENABLE_PIN PIN_B1
#define LCD_RS_PIN PIN_B2
#define LCD_RW_PIN PIN_B3
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#include <lcd.c>
#include <internal_eeprom.c>
int32 A = 0, B = 0;
int1 boton = false;
void main(void)
{
char y=1; //indice columnas
signed char x=1; //indice filas
lcd_init(); // Inicia LCD
lcd_putc("Inicializando el\n"); // Saca texto
lcd_putc("Equipo Aguarde "); // Saca texto
delay_ms(500); // Retardo
lcd_putc("\f"); // Limpia pantalla
A = read_int32_eeprom(0x00); // Lee contador de la EEPROM
B = read_int32_eeprom(0x00);
while(true)
{
{
lcd_gotoxy(x,y); //cursor para escribir mensaje
lcd_putc("kapotik.kapotik.kapotik.kapotik"); //muestra por pantalla el mensaje
delay_ms(250);
x++; //incremento indice de filas
if(x>16){ //¿ya se ha mostrado mensaje entero por 1ºfila?
x=-8; //SI -> indice fila x=-8
x++; //incremento indice columnas
}
lcd_putc("\f"); //borra pantalla
} //...infinito
if(!input(pin_A0) && !boton) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
boton = true;
write_int32_eeprom(0x00, A);
delay_ms(50);
B = read_int32_eeprom(0x00);
}
if(input(pin_A0))
boton = false; // Al soltar el Boton...
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
lcd_gotoxy(1,2); // Acomoda cursor LCD
printf(lcd_putc, "valor %Lu ", B); // Imprime 16 espacios en el LCD
}
}
Hola kapotik, en cuanto tenga un momento libre voy a revisar el programa a ver que veo. En cuanto a lo del uso de la rom, recuerda que la variable B era solo para probar, por lo que la debes eliminar del programa y usar solo la variable A. De todos modos debes pensar en cambiar de PIC por uno con más capacidad de memoria.
Saludos!
delay_ms(250);OK, ya puede ver tu programa y efectivamente se pierden pulsaciones. Esto es debido a esta instrucción:Código: [Seleccionar]delay_ms(250);
Cuando esa instrucción está activa (contando su tiempo), ninguna otra instrucción funciona, (excepto las interrupciones). Vas a tener que eliminar esa instrucción y utilizar la interrupción de uno de los Timers del PIC para contar los 250 mSeg. Allí activas una bandera que vas a aplicar a una condicional (por ejemplo if) para hacer el avance del letrero en la pantalla y luego de esto desactivarla para esperar otra interrupción.
Saludos!
Es fácil, más tarde te pongo un ejemplo.
saludos!
Bueno, le hice unos cambios al programa para evitar el parpadeo que produce borrar toda la pantalla y le eliminé la variable B. Le adicioné un Timer que cuenta 262 mSeg. para reemplazar la instrucción delay_ms(). Lo ensayas y me cuentas. Puedes experimentar con la configuración del Timer para conseguir otros tiempos (leer y estudiar el uso de los Timers).
Saludos!
printf(lcd_putc, "valor %Lu ", B);Hola kapotik, en realidad el código que estás usando para hacer que se mueva el letrero hacia la derecha es bastante simple y no utiliza las funciones que te mencionó Marcos en un post anterior. Este código solo aprovecha la función lcd_gotoxy(x,y) para mover el letrero de izquierda a derecha, pero como podrás observar, el letrero nunca comienza letra a letra desde la izquierda, sino que aparece entero y se va desvaneciendo por la derecha. Tendrías que buscar un poco más en el foro para encontrar uno que si utilice las funciones de corrimiento de caracteres a la derecha o izquierda.
En la página 211 del manual de CCS (http://www.ccsinfo.com/downloads/ccs_c_manual.pdf), puedes ver el uso correcto de printf().
Saludos!
#include <16F628A.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES XT //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#use delay(clock=4000000)
#rom 0x2100 ={0,0,0,0}
#define LCD_ENABLE_PIN PIN_B1
#define LCD_RS_PIN PIN_B2
#define LCD_RW_PIN PIN_B3
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#include <lcd.c>
#include <internal_eeprom.c>
int32 A = 0;
int1 boton = false, T_mSeg = false;
#int_TIMER1
void TIMER1_isr(void)
{
T_mSeg = true;
}
void main()
{
char y=1; // indice columnas
signed char x=1; // indice filas
setup_timer_1(T1_INTERNAL|T1_DIV_BY_4); //262 ms overflow
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
lcd_init(); // Inicia LCD
lcd_putc("Inicializando el\n"); // Saca texto
lcd_putc("Equipo Aguarde "); // Saca texto
delay_ms(1000); // Retardo
lcd_putc("\f"); // Limpia pantalla
A = read_int32_eeprom(0x00); // Lee contador de la EEPROM
while(TRUE)
{
lcd_gotoxy(x,y); // cursor para escribir mensaje
lcd_putc("kapotik.kapotik.kapotik.kapotik"); // muestra por pantalla el mensaje
if(T_mSeg) // Si pasaron 262 mSeg. aprox...
{
x--; // incremento indice de filas
if(x>16) // ¿ya se ha mostrado mensaje entero por 1ºfila?
{
x=-8; // SI -> indice fila x=-8
x++; // incremento indice columnas
}
lcd_gotoxy(1,1); // Borro solamente la primera línea del LCD
lcd_putc(" ");
T_mSeg = false; // Desactivo la bandera
}
if(!input(pin_A0) && !boton) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
boton = true;
write_int32_eeprom(0x00, A);
delay_ms(50);
}
if(input(pin_A0))
boton = false; // Al soltar el Boton...
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
lcd_gotoxy(1,2); // Acomoda cursor LCD
printf(lcd_putc, "valor %Lu ", A); // Imprime 16 espacios en el LCD
}
}Hola kapotik, en realidad el código que estás usando para hacer que se mueva el letrero hacia la derecha es bastante simple y no utiliza las funciones que te mencionó Marcos en un post anterior. Este código solo aprovecha la función lcd_gotoxy(x,y) para mover el letrero de izquierda a derecha, pero como podrás observar, el letrero nunca comienza letra a letra desde la izquierda, sino que aparece entero y se va desvaneciendo por la derecha. Tendrías que buscar un poco más en el foro para encontrar uno que si utilice las funciones de corrimiento de caracteres a la derecha o izquierda.Para hacer que aparezca letra a letra desde derecha a izquierda, solo debes poner como punto de origen la posicion 16 de la linea donde quieras mostrarlo...
En la página 211 del manual de CCS (http://www.ccsinfo.com/downloads/ccs_c_manual.pdf), puedes ver el uso correcto de printf().
Saludos!
Para hacer que aparezca letra a letra desde derecha a izquierda, solo debes poner como punto de origen la posicion 16 de la linea donde quieras mostrarlo...
#include <16F628A.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES XT //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#use delay(clock=4000000)
#rom 0x2100 ={0,0,0,0}
#define LCD_ENABLE_PIN PIN_B1
#define LCD_RS_PIN PIN_B2
#define LCD_RW_PIN PIN_B3
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#include <lcd.c>
#include <internal_eeprom.c>
int32 A = 0;
int1 boton = false, T_mSeg = false;
#int_TIMER1
void TIMER1_isr(void)
{
T_mSeg = true;
}
void main()
{
char y=1; // indice columnas
signed char x=1; // indice filas
setup_timer_1(T1_INTERNAL|T1_DIV_BY_4); //262 ms overflow
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
lcd_init(); // Inicia LCD
lcd_putc("Inicializando el\n"); // Saca texto
lcd_putc("Equipo Aguarde "); // Saca texto
delay_ms(1000); // Retardo
lcd_putc("\f"); // Limpia pantalla
A = read_int32_eeprom(0x00); // Lee contador de la EEPROM
while(TRUE)
{
lcd_gotoxy(x,y); // cursor para escribir mensaje
lcd_putc("kapotik.kapotik.kapotik.kapotik"); // muestra por pantalla el mensaje
if(T_mSeg) // Si pasaron 262 mSeg. aprox...
{
x--; // incremento indice de filas
if(x<-9) // ¿ya se ha mostrado mensaje entero por 1ºfila?
{
x=16; // SI -> indice fila x=-8
x++; // incremento indice columnas
}
lcd_gotoxy(1,1); // Borro solamente la primera línea del LCD
lcd_putc(" ");
T_mSeg = false; // Desactivo la bandera
}
if(!input(pin_A0) && !boton) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
boton = true;
write_int32_eeprom(0x00, A);
delay_ms(50);
}
if(input(pin_A0))
boton = false; // Al soltar el Boton...
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
lcd_gotoxy(1,2); // Acomoda cursor LCD
printf(lcd_putc, "valor %Lu ", A); // Imprime 16 espacios en el LCD
}
}Corrección!!! Disculpa Marcos, si se puede hacer como dices! :-/ Hola kapotik, utiliza este programa y nos cuentas:Código: C
Saludos!
if(x<-30) if(x<-22)Hola kapotik y el código?
Saludos!
include <16F628A.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES XT //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES PROTECT
#use delay(clock=4000000)
#rom 0x2100 ={0,0,0,0}
#define LCD_ENABLE_PIN PIN_B1
#define LCD_RS_PIN PIN_B2
#define LCD_RW_PIN PIN_B3
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
#include <lcd.c>
#include <internal_eeprom.c>
int32 A = 0;
int1 boton = false, T_mSeg = false;
#int_TIMER1
void TIMER1_isr(void)
{
T_mSeg = true;
}
void main()
{
char y=1; // indice columnas
signed char x=16; // indice filas
setup_timer_1(T1_INTERNAL|T1_DIV_BY_4); //262 ms overflow
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
lcd_init(); // Inicia LCD
lcd_putc("Inicializando el\n"); // Saca texto
lcd_putc(" equipo aguarde "); // Saca texto
delay_ms(2000); // Retardo
lcd_putc("\f"); // Limpia pantalla
A = read_int32_eeprom(0x00); // Lee contador de la EEPROM
while(TRUE)
{
lcd_gotoxy(x,y); // cursor para escribir mensaje
lcd_putc("0123456789.kapotik.abcdefghi"); // muestra por pantalla el mensaje
if(T_mSeg) // Si pasaron 262 mSeg. aprox...
{
x--; // incremento indice de filas
if(x<-31) // ¿ya se ha mostrado mensaje entero por 1ºfila?
{
x=16; // SI -> indice fila x=-8
x++; // incremento indice columnas
}
lcd_gotoxy(1,1); // Borro solamente la primera línea del LCD
lcd_putc(" ");
T_mSeg = false; // Desactivo la bandera
}
if(!input(pin_A0) && !boton) // Pregunta si RA0 es cero
{
A++; // Incremento el conteo
boton = true;
write_int32_eeprom(0x00, A);
delay_ms(50);
}
if(input(pin_A0))
boton = false; // Al soltar el Boton...
if(A>=9999999) // Preguto si A es mayor o igual a 9999999,
{ // cuando sea igual iguala "A" a cero
A=0;
}
lcd_gotoxy(1,2); // Acomoda cursor LCD
printf(lcd_putc, "VALOR:%Lu ", A); // Imprime 16 espacios en el LCD
}
}
Hola, hiciste los 3 cambios en el programa? De ser así, voy a mirar si saco un rato de aquí a mañana para montarlo en físico y ver que pasa.
Saludos!
Hola.
Yo lo hago asi:Código: C#
En donde msj_rom es donde guardo el mensaje largo y mensaje_inicial es el bufer de memoria para la LCD -de unos 24 caracateres para la LCD que yo uso-, la variable sweep la controlo con un timer (para el tiempo de scroll).
Saludos
Excelente me funciona perfecto lo del scroll text ((:-)) en la lcd,aunque no me gusta mucho ccs,lo utilizo por que el profesor lo esta usando :5]
Muchas gracias me gusta este foro :lol:
Hola.
Que parte no te funciona?
El codigo que esta ahi es parte de otro codigo :P ... por lo que habria que definir ciertas variables como lo son:
vista_inicial : tipo boolean
mensaje : tipo boolean
mensaje_incial : arreglo tipo char
sweep : tipo boolean
i,k : tipo int
la constante msj_rom es donde guardo el string que se quiere visualizar ... algo como: const char msj_rom[]={"Hola mundo"};
Saludos