LCD.C de CCS

[Algec]

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?

[El_Coach]

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

[Algec]

Lo probare y ta te digo, gracias.

[Algec]

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.

[Algec]

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?

[RaDoN]

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

[Algec]

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?

[RaDoN]

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

[Algec]

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

[RaDoN]

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!

[Algec]

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";
}

[RaDoN]

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

[Algec]

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

[RaDoN]

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

[El_Coach]

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.