TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: RaDoN en 08 de Agosto de 2005, 11:03:00

Título: LCD.C de CCS
Publicado por: RaDoN en 08 de Agosto de 2005, 11:03:00

Seguro que habeis escuchado esta pregunta mil veces!!! ¿Porque no rula el LCD con esta libreria corriendo a 20mhz y sí a 4?

¡¡He cambiado los delay_cycle por delay_us!! Y sigue sin ir ... ¿Necesita algo más? O en principio con eso basta ... de ser así me voi a volver loco.

P.D.:¿ alguien tiene el bootloader para un 877A a 4mhz y 192000bps?

Título: RE: LCD.C de CCS
Publicado por: aprendiz_de_Pic en 08 de Agosto de 2005, 15:36:00

QUE TAL RADON

Saludos desde Mexico.  
 
Yo tengo uno lo voy a buscar, no se si te sirva pero a mi me ha funcionado bien,  lo busco y te lo mando a tu correo espero tenga espacio,  este lo uso con el PICdownloader, que tambien te anexare, suerte y cuenta si te sirvio.

Chicos del foro si a alguien mas le interesa avisenme o digan donde lo puedo subir

Título: RE: LCD.C de CCS
Publicado por: Algec en 09 de Agosto de 2005, 03:32:00

si el lcd de ccs no funciona a 20Mhz tambien me interesa a mi que lo publiques el que funciona. PEgalo aqui si te parece
Gracias

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 09 de Agosto de 2005, 04:49:00

Muchas gracias, mi correo es : the_radon@hotmail.com

Aver si alguien tiene algo para el LCD a 4 bits y 20 Mhz ...
Respecto al bootloader tb uso el PICdownloader solo que para el 877A solo encuentro  a 20mhz y no a 4mhz (que si tengo para la version 877 pero no sirve para el "A"

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 09 de Agosto de 2005, 05:02:00

Juas, esto me pasa por no leer ... acabo de ver esta nota:


Info on Crystal-Frequency and Baudrate:

The Bootloaderfile for 16MHz/38400bps can also be used
for 8MHz/19200bps or 4MHz/9600bps

The Bootloaderfile for 20MHz/38400bps can also be used
for 10MHz/19200bps



Pero sigo con la pega del LCD, me gustaria hacerlo andar a 20 Mhz

Título: RE: LCD.C de CCS
Publicado por: El_Coach en 09 de Agosto de 2005, 06:55:00

Hola, yo lo tengo funcionando a 20MHz con este driver.
El driver es marca de la casa, lo adapte para poder utilizar cualquier pin del pic, asi que tambien servira para la gente que buscaba algo asi.

Codigo:

// coach_lcd.c
//
// Funciones para la gestion del display 2x16 [ByCoach]:
//
//  lcd_iniciar()   Debe ser llamada antes que las otras funciones.
//
//  lcd_putc(c)  Visualiza c en la siguiente posición del display.
//               Caracteres especiales de control:
//                      f  Borrar display
//                      
  Saltar a la segunda linea
//                        Retroceder una posición.
//
//  lcd_gotoxy(x,y) Selecciona la nueva posicion de escritura en el display.
//                  (la esquina superior izquierda es 1,1)
//
//  lcd_getc(x,y)   Devuelve el caracter de la posicion x,y del display.

//Definición de pines:

#define   lcd_rs      PIN_C0                                          //
#define   lcd_rw      PIN_C1                                          //
#define   lcd_en      PIN_C2                                          //
#define   lcd_DB4      PIN_C4                                          //
#define   lcd_DB5      PIN_C5                                          //
#define   lcd_DB6      PIN_C6                                          //
#define   lcd_DB7      PIN_C7   

void   lcd_enviar_nibble( int nibble )
{
   output_bit( lcd_DB4, bit_test( nibble, 0 ) );   //Pone en el puerto B[4..7] el valor en nibble[0..3]
   output_bit( lcd_DB5, bit_test( nibble, 1 ) );
   output_bit( lcd_DB6, bit_test( nibble, 2 ) );
   output_bit( lcd_DB7, bit_test( nibble, 3 ) );
   delay_us( 1 );
   output_high( lcd_en );   //Activa y desactiva enable para que el lcd capture el nibble
   delay_us( 2 );
   output_low( lcd_en );
}

int   lcd_leer_byte( void )
{
   int valor = 0;

   output_high( lcd_rw );   //Se activa rw indicando que se va a realizar una lectura
   delay_us( 1 );
   output_high( lcd_en );   //Se activa enable para que el lcd saque la parte alta del byte deseado
   delay_us( 1 );         //por los pines de datos
   
   if( input( lcd_DB7 ) )   //Se captura la parte alta del byte deseado
      bit_set( valor, 7 );
   if( input( lcd_DB6 ) )
      bit_set( valor, 6 );
   if( input( lcd_DB5 ) )
      bit_set( valor, 5 );
   if( input( lcd_DB4 ) )
      bit_set( valor, 4 );

   output_low( lcd_en );   //Se desactiva y se vuelve a activar enable para que el lcd saque la parte
   delay_us( 1 );         //baja del byte deseado por los pines de datos
   output_high( lcd_en );
   delay_us( 1 );

   if( input( lcd_DB7 ) )   //Se captura la parte baja del byte deseado
      bit_set( valor, 3 );
   if( input( lcd_DB6 ) )
      bit_set( valor, 2 );
   if( input( lcd_DB5 ) )
      bit_set( valor, 1 );
   if( input( lcd_DB4 ) )
      bit_set( valor, 0 );

   output_low( lcd_en );   //Se desactiva enable, indicando al lcd el fin de la lectura del byte

   return( valor );   //Devuelve el byte capturado
}

void   lcd_enviar_byte( int dir, int valor )   //Si recibe en dir un 1 se trata de un dato y si es un 0 es un comando
{
   output_low( lcd_rs );
   while( bit_test( lcd_leer_byte(), 7 ) );   //Lectura del Flag de Busy (ocupado), si 1 se espera, si 0 se continúa
   output_bit( lcd_rs, dir );               //Se asigna a rs el valor de dir para indicar si es dato o comando
   delay_us( 1 );
   output_low( lcd_rw );            //Se pone a cero rw para indicar que se va a realizar una escritura
   delay_us( 1 );
   output_low( lcd_en );            //Se pone a cero enable para preparar el valor a enviar
   lcd_enviar_nibble( valor >> 4 );   //Se envía primero la parte alta del byte
   lcd_enviar_nibble( valor & 0x0F );   //a continuación se envía la parte baja
}

void   lcd_posicionar( int x, int y )      //Se reciben las coordenadas x e y a las que se desea desplazarse
{
   int   dir;

   if ( y != 1 )      //La posición "y" determinará la línea elegida, si es 1 -> Línea 1, si no -> Línea 2
      dir = 0x40;      //Dirección de la RAM del LCD para la 2ª línea
   else
      dir = 0x00;      //Dirección de la RAM del LCD para la 1ª línea

   dir += x - 1;      //Resta uno, ya que la posición 1 sería la 0 para el lcd
   lcd_enviar_byte( 0, dir | 0x80 );   //Se envía el byte, indicando que es un comando y poniendo el bit
}                              //más significativo a 1, para diferenciar este comando de los demás

void   lcd_iniciar( void )
{
   int   i;
   int   bytes_inicio[4] = { 0x28, 0x0C, 0x01, 0x06 };

   output_low( lcd_rs );      //Pone a cero todos los pines de control
   output_low( lcd_rw );
   output_low( lcd_en );
   delay_ms( 30 );
   
   for ( i = 1 ; i <= 3 ; i++ )
   {
      lcd_enviar_nibble( 3 );
      delay_ms( 5 );
   }
   
   lcd_enviar_nibble( 2 );

   for( i = 0 ; i <= 3 ; i++ )      //Se configura el lcd con las características indicadas anteriormente
      lcd_enviar_byte( 0 , bytes_inicio );
}

void   lcd_putc( char c )   //Se recibe el caracter a enviar
{
   switch( c )
   {
      case "f" :   lcd_enviar_byte( 0, 1 );   //Si c = "f", se envía un 1, e indica que es un comando
               delay_ms( 2 );            //Enviando un 1, se borra la pantalla del lcd
               break;
      case "
" :   lcd_posicionar( 1, 2 );      //Si c = "
", se posiciona en la segunda línea
               break;
      case "" :   lcd_enviar_byte( 0, 0x10 );   //Si c = "", se sitúa una posición a la izquierda
               break;
      default   :   lcd_enviar_byte( 1, c );   //Si no es ninguna de las anteriores, envía un caracter
               break;
   }
}

char   lcd_getc( int x,int y )   //Se reciben las coordenadas x e y de las que se desea el dato
{
   char   valor;
   lcd_posicionar( x, y );      //Se posiciona en el punto deseado
   output_high( lcd_rs );      //Pone a 1 el pin rs, indicando que se trata de un dato
   valor = lcd_leer_byte();   //Lee el byte de la posición deseada
   output_low( lcd_rs );
   return( valor );         //Devuelve el caracter leído
}

Espero haberos ayudado

Saludos y buen verano!

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 09 de Agosto de 2005, 08:41:00

Muchas gracias!!! lo probare en cuanto pueda ..

Título: RE: LCD.C de CCS
Publicado por: aprendiz_de_Pic en 09 de Agosto de 2005, 11:27:00

Que tal chicos una disculpa .   Yo me referia a la peticion de la P.D  sobre que necesitaba radon un bootloader y no al LCD.  Digo solo para hacer la aclaracion.

Me acabo de conectar radon asi que en unos instantes te mando el bootloader junto con el Picdownloader,  espero te sea de utilidad.


y reitero si alguin mas lo necesita digan donde lo subo? ó denme su direccion y se los haré llegar.

David
Saludos desde México

Título: RE: LCD.C de CCS
Publicado por: Algec en 09 de Agosto de 2005, 16:06:00

A mi me interesan gracias
masmontero@hotmail.com

Título: RE: LCD.C de CCS
Publicado por: LordLafebre en 09 de Agosto de 2005, 16:54:00

Hola:

A mi tambien me interesa....

g_lafebre@yahoo.com

Título: RE: LCD.C de CCS
Publicado por: Algec en 16 de Agosto de 2005, 07:07:00

YO probe tu driver y no me funciona ni a 4 MHZ, querria ponerlo en marcha y no se porque no va. TEngo uno que me funciona bien a 4 pero quiero hacer trabajar el 16F877 a 20 y usar el tuyo. ME gusta como esta hecho.
DIme que programa de pruebas utilizas o con que aplicacion cargada en el pic a ver si veo donde esta el fallo.
Gracias

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 16 de Agosto de 2005, 08:01:00

Yo no he tenido tiempo para probarlo aún, ¿y dices que no te va? ¿Estas seguro que has configurado los pines correctamente en el LCD?

Codigo:

#define   lcd_rs      PIN_C0                                          //

#define   lcd_rw      PIN_C1                                          //

#define   lcd_en      PIN_C2                                          //

#define   lcd_DB4      PIN_C4                                          //

#define   lcd_DB5      PIN_C5                                          //

#define   lcd_DB6      PIN_C6                                          //

#define   lcd_DB7      PIN_C7   

Tu nos dirás

Título: RE: LCD.C de CCS
Publicado por: Algec en 16 de Agosto de 2005, 08:07:00

he cambiado el puerto al D, es el unico cambio. Bueno tambien el nombre de las funciones para que sean identicas a en las dos librerias.
TE pego el cambio

//Definicion de pines:

#define   lcd_rs      PIN_D0                                          //
#define   lcd_rw      PIN_D1                                          //
#define   lcd_en      PIN_D2                                          //
#define   lcd_DB4      PIN_D4                                          //
#define   lcd_DB5      PIN_D5                                          //
#define   lcd_DB6      PIN_D6                                          //
#define   lcd_DB7      PIN_D7
 
Es similar al de la otra libreria


y solo el nombre de las funciones que pasan a ser lcd_init()
es la unica que cambie.
Lo demas quedo igual y no va en ese puerto.

En otro post estan pegadas las dos librerias la que funciona y la que no, echale un vistazo, te estare muy agradecido-

Título: RE: LCD.C de CCS
Publicado por: Algec en 16 de Agosto de 2005, 08:08:00

por cierto lo de usar el D no es mania mia sino que uso I2C y RS232 y queria dejar el puerto C libre para eso.

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 16 de Agosto de 2005, 08:10:00

Ya, yo tb uso el puerto D para el LCD, ademas es el mas indicado, el A son para los analogicos al igual que el E, el B son para entradas sobre todo por ello de las resistencias pull-up, así que, el msa idoneo es el D para esta labor

Título: RE: LCD.C de CCS
Publicado por: Algec en 16 de Agosto de 2005, 13:02:00

Pues esa libreria con tu ejemplo de menu no funciona, en cambio la que tengo yo si. Claro que trabajo a 4 megas. Quiero hacerla funcionar a 20 y si dicen que funciona a 20 porque no a 4?

Título: RE: LCD.C de CCS
Publicado por: El_Coach en 16 de Agosto de 2005, 17:30:00

Hola, supongo que utilizais el siguiente comando para mostrar en el lcd:


printf(LCD_PUTC, "hola";


Se supone que con la libreria lcd.c que trae el ccs funciona así, pero al probarlo con la mia no funciona. No entiendo el motivo, así que yo lo hago así:


#include <string.h>

........
........

char    cadena[20];

sprintf( cadena, "hola" );

for ( j = 0 ; j < strlen(cadena) ; j++ )
    lcd_putc( cadena[j] );


que es lo mismo que:


    lcd_putc( "h" );
    lcd_putc( "o" );
    lcd_putc( "l" );
    lcd_putc( "a" );


Es un poco coñazo, pero así me va perfecto, con xtal de 20mhz, no creo que influya el valor del xtal.
Si alguien encuentra el fallo que lo diga y así será mejor para todos
También se acepta depuración de código

Un saludo

Título: RE: LCD.C de CCS
Publicado por: Algec en 17 de Agosto de 2005, 08:37:00

Lo probare y ta te digo, gracias.

Título: RE: LCD.C de CCS
Publicado por: Algec en 17 de Agosto de 2005, 10:55:00

Bien lo probe y escribir escribe, pero ahora tengo problemas con el LCD, porque escribe donde le parece y ademas los caracteres que le parece.
Programas que funcionaban bien ya no van y no se porque.
YA te dire, a ver si alguien que sepa mas ayuda por favor.

Título: RE: LCD.C de CCS
Publicado por: Algec en 18 de Agosto de 2005, 11:40:00

Bueno continua sin funcionar. Hice una pequeña prueba en proteus y descubro que si en el LCD_INIT() no incluyes el set_tris_b() correspondiente, ya que he tratado dde hacerla funcionar exactamente como la tienes tu hecha, pues no hay salidas. Quizas tu lo incluyas en el programa de utilizacion. PEse a incluirlo no hay salida en los 4 bits de menos peso del puerto B en la salida de datos la LCD, pero si la hay en los 3 de control de mayor peso.
Si quieres pruebalo, es simple de probar solo un LCD y el 16F877 y enviar
#include <16f877.h>
#fuses XT,NOWDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000,RESTART_WDT)

#use fast_io(B)

#include <lcd20MHZ.c>

main()
{
  lcd_init();         // Inicializar LCD
while(1)
  lcd_putc("Pulsa una tecla ";
}

Con esto en proteus no va
Alguien sabe porque?

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 18 de Agosto de 2005, 11:46:00

Lo que haga el proteus me creo la mitad, cuando valla en la entrenadora a 20mhz entonces me creo la rutina

Título: RE: LCD.C de CCS
Publicado por: Algec en 18 de Agosto de 2005, 11:49:00

Estoy de acuerdo pero si no va en PRoteus ya mal vamos. EN la entrenadora de momento como en proteus.
VEamos, ya consegui que salieran datos por el nible bajo, pero no pinta.
Solo tuve que quitar los
#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#use fast_io(D)
que tenia en el fichero de uso.
Aun asi no pinta parece ser que esta el LCD mal inicializado. Nos puedes psar un programita que tu uses con esa libreria?

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 18 de Agosto de 2005, 11:54:00

Con la de CCS? Algo sencillo ...

Codigo:

//***********************************************

  #include "16F877.h"
  #fuses NOLVP,XT,NOWDT,NOPROTECT,PUT
  #use delay (clock=4000000)
  #use fast_io(B)

  #include "LCD.C"

  #ORG 0x1F00,0x1FFF {} //for the 8k 16F876/7

  void main(void) {
   lcd_init();
   printf(lcd_putc,"fHola Dani";
   delay_ms(1500);
   printf(lcd_putc,"fAdios Dani";}

Ahora mismo esta "corriendo" en la entrenadora, el driver para el LCD es el del CCS solo que con la configuracion de pines de mi entrenadora .. Como cambie el cristal a 10 o 20 mhz me manda al carajo xD

Título: RE: LCD.C de CCS
Publicado por: Algec en 18 de Agosto de 2005, 12:24:00

Estoy de acuerdo pero ya va en Proteus
VEreis he tenido que modificar algunas cosillas, quitar del programa de uso

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#use fast_io(D)

no se porque

Ademas en la libreria no esta inicializado el puerto D asi que lo hice y quedo de la siguiente manera
// coach_lcd.c
//
// Funciones para la gestion del display 2x16 [ByCoach]:
//
//  lcd_init()   Debe ser llamada antes que las otras funciones.
//
//  lcd_putc(c)  Visualiza c en la siguiente posición del display.
//               Caracteres especiales de control:
//                      f  Borrar display
//                      
  Saltar a la segunda linea
//                        Retroceder una posición.
//
//  lcd_gotoxy(x,y) Selecciona la nueva posicion de escritura en el display.
//                  (la esquina superior izquierda es 1,1)
//
//  lcd_getc(x,y)   Devuelve el caracter de la posicion x,y del display.
//Definicion de pines:

#define   lcd_rs      PIN_D0                                          //
#define   lcd_rw      PIN_D1                                          //
#define   lcd_en      PIN_D2                                          //
#define   lcd_DB4      PIN_D4                                          //
#define   lcd_DB5      PIN_D5                                          //
#define   lcd_DB6      PIN_D6                                          //
#define   lcd_DB7      PIN_D7
#define set_tris_lcd(x) set_tris_d(x)                                // sirve para definir el puerto a usar




void   lcd_enviar_nibble( int nibble )
{
   output_bit( lcd_DB4, bit_test( nibble, 0 ) );   //Pone en el puerto B[4..7] el valor en nibble[0..3]
   output_bit( lcd_DB5, bit_test( nibble, 1 ) );
   output_bit( lcd_DB6, bit_test( nibble, 2 ) );
   output_bit( lcd_DB7, bit_test( nibble, 3 ) );
   delay_us( 1 );
   output_high( lcd_en );   //Activa y desactiva enable para que el lcd capture el nibble
   delay_us( 2 );
   output_low( lcd_en );
}

int   lcd_leer_byte( void )
{
   int valor = 0;

   output_high( lcd_rw );   //Se activa rw indicando que se va a realizar una lectura
   delay_us( 1 );
   output_high( lcd_en );   //Se activa enable para que el lcd saque la parte alta del byte deseado
   delay_us( 1 );         //por los pines de datos

   if( input( lcd_DB7 ) )   //Se captura la parte alta del byte deseado
      bit_set( valor, 7 );
   if( input( lcd_DB6 ) )
      bit_set( valor, 6 );
   if( input( lcd_DB5 ) )
      bit_set( valor, 5 );
   if( input( lcd_DB4 ) )
      bit_set( valor, 4 );

   output_low( lcd_en );   //Se desactiva y se vuelve a activar enable para que el lcd saque la parte
   delay_us( 1 );         //baja del byte deseado por los pines de datos
   output_high( lcd_en );
   delay_us( 1 );

   if( input( lcd_DB7 ) )   //Se captura la parte baja del byte deseado
      bit_set( valor, 3 );
   if( input( lcd_DB6 ) )
      bit_set( valor, 2 );
   if( input( lcd_DB5 ) )
      bit_set( valor, 1 );
   if( input( lcd_DB4 ) )
      bit_set( valor, 0 );

   output_low( lcd_en );   //Se desactiva enable, indicando al lcd el fin de la lectura del byte

   return( valor );   //Devuelve el byte capturado
}

void   lcd_enviar_byte( int dir, int valor )   //Si recibe en dir un 1 se trata de un dato y si es un 0 es un comando
{
   output_low( lcd_rs );
   while( bit_test( lcd_leer_byte(), 7 ) );   //Lectura del Flag de Busy (ocupado), si 1 se espera, si 0 se continúa
   output_bit( lcd_rs, dir );               //Se asigna a rs el valor de dir para indicar si es dato o comando
   delay_us( 1 );
   output_low( lcd_rw );            //Se pone a cero rw para indicar que se va a realizar una escritura
   delay_us( 1 );
   output_low( lcd_en );            //Se pone a cero enable para preparar el valor a enviar
   lcd_enviar_nibble( valor >> 4 );   //Se envía primero la parte alta del byte
   lcd_enviar_nibble( valor & 0x0F );   //a continuación se envía la parte baja
}

void   lcd_gotoxy( int x, int y )      //Se reciben las coordenadas x e y a las que se desea desplazarse
{
   int   dir;

   if ( y != 1 )      //La posición "y" determinará la línea elegida, si es 1 -> Línea 1, si no -> Línea 2
      dir = 0x40;      //Dirección de la RAM del LCD para la 2ª línea
   else
      dir = 0x00;      //Dirección de la RAM del LCD para la 1ª línea

   dir += x - 1;      //Resta uno, ya que la posición 1 sería la 0 para el lcd
   lcd_enviar_byte( 0, dir | 0x80 );   //Se envía el byte, indicando que es un comando y poniendo el bit
}                              //más significativo a 1, para diferenciar este comando de los demás

void   lcd_init( void )
{
   int   i;
   int   bytes_inicio[4] = { 0x28, 0x0C, 0x01, 0x06 };

   set_tris_lcd(0x00);
   
   output_low( lcd_rs );      //Pone a cero todos los pines de control
   output_low( lcd_rw );
   output_low( lcd_en );
   delay_ms( 30 );

   for ( i = 1 ; i <= 3 ; i++ )
   {
      lcd_enviar_nibble( 3 );
      delay_ms( 5 );
   }

   lcd_enviar_nibble( 2 );

   for( i = 0 ; i <= 3 ; i++ )      //Se configura el lcd con las características indicadas anteriormente
      lcd_enviar_byte( 0 , bytes_inicio );
}

void   lcd_putc( char c )   //Se recibe el caracter a enviar
{
   switch( c )
   {
      case "f" :   lcd_enviar_byte( 0, 1 );   //Si c = "f", se envía un 1, e indica que es un comando
               delay_ms( 2 );            //Enviando un 1, se borra la pantalla del lcd
               break;
      case "
" :   lcd_gotoxy( 1, 2 );      //Si c = "
", se posiciona en la segunda línea
               break;
      case "" :   lcd_enviar_byte( 0, 0x10 );   //Si c = "", se sitúa una posición a la izquierda
               break;
      default   :   lcd_enviar_byte( 1, c );   //Si no es ninguna de las anteriores, envía un caracter
               break;
   }
}

char   lcd_getc( int x,int y )   //Se reciben las coordenadas x e y de las que se desea el dato
{
   char   valor;
   lcd_gotoxy( x, y );      //Se posiciona en el punto deseado
   output_high( lcd_rs );      //Pone a 1 el pin rs, indicando que se trata de un dato
   valor = lcd_leer_byte();   //Lee el byte de la posición deseada
   output_low( lcd_rs );
   return( valor );         //Devuelve el caracter leído
}




El programa de uso que funciona en PRoteus es la siguiente chorrada
#include <16f877.h>
#fuses XT,NOWDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP
#use delay(clock=20000000,RESTART_WDT)


#include <lcd20Mhz.c>

main()
{
    lcd_init();         // Inicializar LCD
while(1)
  lcd_putc("Pulsa una tecla ";
}


Probadlo y vereis, lo que necesitamos ahora es que alguien que tenga un prototipo a 20 Mhz lo cargue y lo pruebe, si funciona repararemos la libreria ya que tiene algun defectillo mas.


Dejad noticias por favor

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 18 de Agosto de 2005, 14:13:00

No entiendo que cambios has hecho, pera 1 seg que la pruebo ...

Edito: bueno, la verdad es que hace algo curioso mi LCD 16x2, solo inicializa 1 linea, de la otra ni hablar, y con el 4x20 nada de nada (eso a 4 Mhz, porque a 20 mejor ni comento ).

Por cierto, ¿puedes comentar las diferencias con la libreria del CCS?, ¿no seria mas facil modificar esta? Thanks!

Título: RE: LCD.C de CCS
Publicado por: Algec en 18 de Agosto de 2005, 17:40:00

A mi me funciona en la tarjeta a 4 Mhs las dos lineas. VA bien con cualquier ficherito que pruebo. Lo que necesito es un micro a 20 y poder probar.
Te pego otro ficherito que funciona en LCD 2x20 que uso, funciona bien.
SIMPLE Y USA LAS DOS LINEAS, PRUEBALO, EN MI PLACA FUNCIONA

#include <16f877.h>
#fuses XT,NOWDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000,RESTART_WDT)


#include <lcd20Mhz.c>

main()
{
    lcd_init();         // Inicializar LCD
  lcd_putc("abcdefghijklmnopqrst";
   lcd_gotoxy(1,2);
  lcd_putc("uvwxyz1234567890";
}

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 19 de Agosto de 2005, 02:56:00

Aja, yo usaba "
" para cambiar de linea ... pero a 20mhz sigue sin ir

Título: RE: LCD.C de CCS
Publicado por: Algec en 19 de Agosto de 2005, 03:17:00

A 4 trabaja bien,no comprendo como puede hacerlo funcionar a 20, insisto que pegue el programa de uso y probare

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 19 de Agosto de 2005, 03:19:00

Ahora mismo no puedo probar nada mas me he quedado sin fuente ... he quemado el fusible trasteando con ella para ver si podria microcontrolarla

Título: RE: LCD.C de CCS
Publicado por: El_Coach en 19 de Agosto de 2005, 10:40:00

Debo de corregir mi anterior mensaje, yo para mostrar por lcd lo hago así:

lcd_putc("Hola";

Lo del sprintf es solo cuando quiero mostrar el valor de una variable, pero sólo con carácteres va bien. Perdón por el fallo pero estas ultimas semanas he andado de allá para acá y debí confundirme.

Mi programa de muestra:

Codigo:

#include<18F2550.h>
#include <string.h>

#fuses   HS,NOPROTECT,NOBROWNOUT,NOWDT,NOPUT,NOCPD,NOSTVREN,NODEBUG,NOLVP,NOWRT,NOWRTD,NOIESO,NOFCMEN,NOPBADEN,NOWRTC,NOWRTB,NOEBTR,NOCPB,NOMCLR

#use   delay(clock=20000000)   //Oscilador a 20MHz

#include<coach_lcd.c>

void   main(void)
{
   int   a, i;
   char   cadena[33];

   lcd_iniciar();

   lcd_putc( "f" );   //Borro e imprimo al principio
   lcd_putc( "Hola" );

   a = 5;
   sprintf( cadena, "a = %u", a);

   lcd_putc( "
" );            //Paso a la siguiente línea y escribo "a = 5"
   for ( i = 0 ; i < strlen(cadena) ; i++ )
      lcd_putc(cadena[ i ]);

   while(1);
}

A mi me funciona sin poner las directivas #use fast_io(X) , en mi programa cambian constantemente  la configuración de los pines así que no utilizo fast_io por comodidad, así por defecto configura el puerto como standard_io. Eso puede ser un motivo de que no funcione en vuestros programas, pero como ya os dije acepto todo tipo de cambios en el driver. Lo hice para uso propio, ya que no me quiero complicar la vida más de lo necesario en mis programas, pero podeis modificarlo todo lo que querais. Lo único que hice fué actuar sobre cada pin individualmente, pero siempre tomando como ejemplo el driver del ccs. Todo el driver está basado en el del ccs, así que podeis comparar las funciones con las del ccs para ver lo que hacen.

Mi pic es un 18F2550, como se puede ver en el ejemplo, y yo lo pruebo todo siempre directamente sobre placa, ya que nunca conseguí marchar bien el proteus.

Un saludo, y perdonad por las tardanzas en contestar pero no puedo hacer más.

Título: RE: LCD.C de CCS
Publicado por: El_Coach en 19 de Agosto de 2005, 10:51:00

Una cosita, encontré una errata en el driver cuando lo postee.
Al escribir un menseje en el foro cuando escribes una i entre [ ], automaticamente lo elimina y lo toma como indicación para escribir en cursiva.
No se si influirá en algo pero debeis revisar esta parte:

void   lcd_iniciar( void )
{
   int   i;
   int   bytes_inicio[4] = { 0x28, 0x0C, 0x01, 0x06 };

   output_low( lcd_rs );      //Pone a cero todos los pines de control
   output_low( lcd_rw );
   output_low( lcd_en );
   delay_ms( 30 );
   
   for ( i = 1 ; i <= 3 ; i++ )
   {
      lcd_enviar_nibble( 3 );
      delay_ms( 5 );
   }
   
   lcd_enviar_nibble( 2 );

   for( i = 0 ; i <= 3 ; i++ )      //Se configura el lcd con las características indicadas anteriormente
      lcd_enviar_byte( 0 , bytes_inicio[ i ] ); //Aqui podria haber ERROR en el [ i ]
}
[/code]

Tan solo era eso, no veo que sea un motivo para que no funcione a 20mhz, pero que se sepa.

Un saludorrrrr

Título: RE: LCD.C de CCS
Publicado por: Algec en 20 de Agosto de 2005, 02:39:00

Lo de la errata ya lo solucione, me habia dado cuenta. De hecho el driver esta funcionando. Lo que necesito es que alguien lo pruebe en un 16f877 a 20 porque los que yo tengo son a 4.

Título: RE: LCD.C de CCS
Publicado por: El_Coach en 20 de Agosto de 2005, 04:29:00

Te digo que yo lo tengo funcionando a 20mhz, que sea un 16f877 o un 18f2550 es indiferente. No entiendo como os puede funcionar a 4 y no a 20...

Título: RE: LCD.C de CCS
Publicado por: Algec en 20 de Agosto de 2005, 05:51:00

te creo, es que no he podido probarla aun porque no tengo ese micro
Gracias tio, la libreria me gusta, esta clarita y funciona bien.

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 20 de Agosto de 2005, 06:25:00

Yo lo que no entiendo,es porque no funciona a 20mhz la propia del CCS

Título: RE: LCD.C de CCS
Publicado por: J1M en 20 de Agosto de 2005, 07:14:00

es por los delay_cycle ... prueba a poner delay_us .. y algun valor mas menos acorde a la frecuencia d tu reloj, ves jugando con los valores hasta q encuentres alguno q haga q funcione el LCD... yo lo solucioné con una librería a 10Mhz q tenia tu mismo problema

saludos!

Título: RE: LCD.C de CCS
Publicado por: RaDoN en 20 de Agosto de 2005, 08:56:00

Si los delay cycles, estan sustituidos por delay_us, con lo que se supone que 1uS es 1uS a 20, 10, 4 o la velocidad que sea ... probare a aumentarlos pero por hacerlo, porque realmente no lo entiendo