LCD Picdem2plus y CCS

[T0ni0]

Hola a todos,

Dispongo de la Picdem2plus con una LCD de 4 bits, y resulta que con el CCS pues no se me adapta bien, sus conexiones son las siguientes:

 

Sabe alguien que debo cambiar en el LCD.c ??

[pikman]

Hola el problema es que hay que independizar el puerto de control de la estructura es un muy bonito el ejemplo de CCS pero se les escapo este detalle aqui te pego el codigo que modifique, deberas arreglarlo a la disposicion de tus I/O del porta y el portb

espero te ayude.

saludos

ARIEL



#define use_portb_lcd


struct lcd_pin_map {                 // This structure is overlayed
           boolean unused;           // low order up.  ENABLE will
           boolean rw1;               // The bits are allocated from
           boolean rs1;               // access to the LCD pins.
           boolean enable1;           // on to an I/O port to gain
           Int     data : 4;         // be pin B0.
        } lcd;





   #byte lcd = 6                  // on to port B (at address 6)

   #define set_tris_lcd(x) set_tris_b(x)


// definicion de lineas de control en porta

#define      rw      PIN_A0
#define      rs      PIN_A1
#define      enable  PIN_A2


#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
#define lcd_line_two 0x40    // LCD RAM address for the second line


// fijo linea 1 y 2
byte CONST LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};

/// rota linea 1 de derecha a izquierda
//byte CONST LCD_INIT_STRING[4] = {0x20 | (lcd_type << 0 ), 0xc, 1, 7 };
                             // These bytes need to be sent to the LCD
                             // to start it up.


                             // The following are used for setting
                             // the I/O port direction register.

                                                  // se dejan como entradas los pines
                                                  // rbo:rb2 y rb3 como salida
                                                  // esto es porque si no pone todo como
                                                  // salida y la caga mal

STRUCT lcd_pin_map const LCD_WRITE = {3,0,0,0,0}; // For write mode all pins are out
STRUCT lcd_pin_map const LCD_READ = {3,0,0,0,15}; // For read mode data pins are in



byte lcd_read_byte() {
      byte low,high;
      set_tris_lcd(LCD_READ);
//      set_tris_b (0B11110111);                   // set portb como entrada/salida
      output_high(rw);
      delay_us(3);
      output_high(enable);
      delay_us(3);
      high = lcd.data;
      output_low(enable);
      delay_us(3);
      output_high(enable);
      delay_us(3);
      low = lcd.data;
      output_low(enable);
//      set_tris_b (0B00000111);                   // set portb como entrada/salida

      set_tris_lcd(LCD_WRITE);
      return( (high<<4) | low);
}


void lcd_send_nibble( byte n ) {
      lcd.data = n;
      delay_us(3);
      output_high(enable);
      //lcd_A.enable = 1;
      delay_us(2);
      output_low(enable);
      //lcd_A.enable = 0;
}


void lcd_send_byte( byte address, byte n ) {

      //lcd_A.rs = 0;
      output_low(rs);
      while ( bit_test(lcd_read_byte(),7) ) ;
      if(address==1)
           output_high(rs);
       else
      output_low(rs);

      //lcd_A.rs = address;
      delay_us(3);
      output_low(rw);

//      lcd_A.rw = 0;
      delay_us(3);
      output_low(enable);

//      lcd_A.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
}


void lcd_init() {
    byte i;
    set_tris_a(0);
//    set_tris_b (0B00001111);                   // set portb como entrada/salida

    set_tris_lcd(LCD_WRITE);
    output_low(rs);
//    lcd_A.rs = 0;
    output_low(rw);
//    lcd_A.rw = 0;
    output_low(enable);
//    lcd_A.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);
 }





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 "
"   : lcd_gotoxy(1,2);        break;
     case ""   : lcd_send_byte(0,0x10);  break;
     default     : lcd_send_byte(1,c);     break;
   }
}

char lcd_getc( byte x, byte y) {
   char value;

    lcd_gotoxy(x,y);
    output_high(rs);
//    lcd_A.rs=1;
    value = lcd_read_byte();
    output_low(rs);
//    lcd_A.rs=0;
    return(value);
}

[T0ni0]

Pues como me daba errores y tenía que cambiar muchas cosas he decidido seguir este hilo aki http://miarroba.com/foros/ver.php?foroid=46840&temaid=3362153

[pikman]

T0nio, el codigo que he posteado esta funcionando, de hecho lo tengo funcionando, no se cual es tu problema, lo unico que debes hacer es redireccionar los puertos de acuerdo a tu harware, si no sabes como hacerlo avisame y te lo arreglo, lo que hay en el otro link que me indicas no esta mal, cuentame cual es error que tienes con la libreria, que no hice yo solo modifique la original de CCS, te puedo pasar una que si es de mi autoria que no usa la linea R/W, que tiene la ventaja de que usa un pin menos del micro, pero la desventaja de que ademas de fallar con algunas pantallas no se puede acceder a la memoria del display que si bien no es mucho en mi caso a veces he usado con muy bueno resultados.

a tus ordenes.

ARIEL / PIKMAN

[T0ni0]

la verdad es que estoy con las mismas, esta librería al compilar me da error aki
 lcd_send_byte(0,LCD_INIT_STRING);

lo cambio por
 lcd_send_byte(0,LCD_INIT_STRING);

y compila, pero aunque adapto los pines me sigue sin funcionar, la LCD no es por que en ASM ya lo tengo resuelto, no se que estaré adaptando mal ?

[T0ni0]

Pues va a ser que con el post anterior me he dado cuenta que el error esta en copiar del post, algunos caracteres no se imprimen je je, seri­a posible enviarme eesa l ­a al correo ? T0ni0

[pikman]

Enviame un privado con tu mail y te la paso.

saludos

ARIEL

[oshow]

Este driver es que suelo utilizar a menudo y funciona muy bien, lo he adaptado a los pines que vas a utilizar.

Codigo:
////////////////////////////////////////////////////////////////////////////////
////                        lcd_modificado.c                                ////
////                 Driver para módulos LCD microcontrolados               ////
////                                                                        ////
////  Inspirado en librería CCS                                           ////
////  Adaptado por Fernando Nuño García y Miguel Ángel José Prieto para     ////
////  funcionamiento con el LCD integrado en la placa PICDEM-2-PLUS.        ////
////                                                                        ////
////  Funciones definidas                                                   ////
////                                                                        ////
////  lcd_init()   Inicialización,llamar antes de cualquier otra función    ////
////                                                                        ////
////  lcd_putc(c)  Muestra c en la posicion siguiente del LCD.              ////
////                  Caracteres de control:                                ////
////                   f  Borra display                                    ////
////                   
  Sitúa cursor al comienzo de la línea 2           ////
////                     Retrocede el cursor una posición                 ////
////                        Avanza el cursor una posición               ////
////                     Retrocede una posición la pantalla visible       ////
////                   v  Avanza una posición la pantalla visible       ////
////                               ////
////                                                                        ////
////  lcd_gotoxy(x,y) Sitúa escritura en posición del LCD          ////
////    (posición 1,1: arriba a la izquierda)                               ////
////                                                                        ////
////  lcd_getc(x,y)   Devuelve carácter en posición x,y del LCD             ////
////                                                                        ////
////////////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,1997 Custom Computer Services                ////
//// This source code may only be used by licensed users of the CCS C       ////
//// compiler.  This source code may only be distributed to other           ////
//// licensed users of the CCS C compiler.  No other use, reproduction      ////
//// or distribution is permitted without written permission.               ////
//// Derivative programs created using this software in object code         ////
//// form are not restricted in any way.                                    ////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Conexión a 7 pines del MCU: 3 de control / interface de datos de 4 bits:   //
//                                                                            //
//    Líneas de control asignadas                                             //
//     RA1  enable                                                            //
//     RA2  rw                                                                //
//     RA3  rs                                                                //
//                                                                            //
//    Líneas de Datos                                                         //
//     RD0  D4                                                                //
//     RD1  D5                                                                //
//     RD2  D6                                                                //
//     RD3  D7                                                                //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

struct lcd_pines_control
        {   // Estructura que se define para facilitar acceso

           boolean nada;
           boolean enable;   // y asociarlos a los 3 bits más bajos del PORTC
           boolean rw;      // asignamos luego a esta estructura el PORTC
           boolean rs;      // rs (1º corresponde al menos significativo
              // a los pines de control del LCD
           int     otros : 4;
        } lcd_control;

struct lcd_pines_datos
       {   // Hacemos lo mismo con esta estructura para el PORTD
           int     datos:4;   // los 4 bits más bajos son los de datos
           int     no_usados:4;
       } lcd_datos;

#byte lcd_control = 5   // Ponemos la estructura entera en el PORTC (registro 7)
#byte trisa = 0x85            // Registro de dirección de datos

#byte lcd_datos =8          // Lo mismo para los datos, en el PORTD (registro 6)
#byte trisd = 0x88          // Registro de dirección de datos

#define lcd_linea_dos 0x40  // Dirección de inicio para la 2ª línea en la DDRAM




////////////////////////////////////////////////////////////////////////////////
///   -Prototipos de las funciones                                            //
////////////////////////////////////////////////////////////////////////////////

void lcd_init();
byte lcd_read_byte();
void lcd_send_nibble(byte n);
void lcd_send_byte(byte address, byte n);
void lcd_gotoxy(byte x, byte y);
void lcd_putc(char c);
char lcd_getc(byte x, byte y);
void lcd_clr_line(char fila);



////////////////////////////////////////////////////////////////////////////////
/// Función que inicializa el LCD, se deberían cambiar bits                   //
//    para cambiar configuracion                                              //
////////////////////////////////////////////////////////////////////////////////

void lcd_init()
{
    byte i;

    trisa&=0b11110001; // Asignamos salidas en RC0, RC1 y RC2, resto puerto
                        //como estaba

    trisd&=0b11110000; // Lo mismo para RD0 a RD3

    lcd_control.rs = 0;
    lcd_control.rw = 0;
    lcd_control.enable = 0;
    delay_ms(15);

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

    lcd_send_byte(0,0b00101000); ///Se envía Function set   0 0 1 DL N F  -  -
    lcd_send_byte(0,0b00001100); ///Se envía Display on/off 0 0 0 0  1 D  C  B
    lcd_send_byte(0,0b00000001); //Se envía Clear Display
    lcd_send_byte(0,0b00000110); //Se envía Entry Mode set  0 0 0 0  0 1 I/D S//

////////////////////////////////////////////////////////////////////////////////
// DL: datos 4 bits(0); 8 bits (1) / N: 2 líneas (1); 1 línea (0) / F: 5x10 (1); 5x8 (0)
// D: display on (1); off (0) / C: cursor on (1); off (0) / B: parpadeo pos.cursor (1); no (0)
// I/D: incremento en R/W (1) o decremento (0) / S: acompaña desplaz.display (1); no (0)
////////////////////////////////////////////////////////////////////////////////
}



////////////////////////////////////////////////////////////////////////////////
// Lee el byte señalado por el puntero, 1º parte alta, 2º parte baja          //
// Si al llamar a esta función rs=0, devuelve busy flag (+signif.)            //
//y dirección actual                                                          //
////////////////////////////////////////////////////////////////////////////////
byte lcd_read_byte()
{
      byte low,high;

      trisa&=0b11110001; //Señales de control (salidas), el resto lo que sean
      trisd|=0b00001111; //Las de datos pasan a ser entradas, las demas igual

      lcd_control.rw = 1;
      delay_cycles(1);
      lcd_control.enable = 1;
      delay_cycles(1);
      high = lcd_datos.datos;
      lcd_control.enable = 0;
      delay_cycles(1);
      lcd_control.enable = 1;
      delay_us(1);
      low = lcd_datos.datos;
      lcd_control.enable = 0;

      trisd&=0b11110000; // Dejamos RD0 a RD3 como salidas

      return( (high<<4) | low);
}



////////////////////////////////////////////////////////////////////////////////
// Envía medio byte, los 4 bits más bajos de n                                //
// Necesario poner rs y rw de modo adecuado y entrar con enable=0             //
////////////////////////////////////////////////////////////////////////////////

void lcd_send_nibble( byte n )
{
      lcd_datos.datos = n;
      delay_cycles(1);
      lcd_control.enable = 1;
      delay_us(2);
      lcd_control.enable = 0;
}



////////////////////////////////////////////////////////////////////////////////
//    -Envía un byte (n) al registro de instrucciones (si address=0) ó        //
//             reg. de datos (address=1)                                      //
//                                                                            //
//                                                                            //
//    -Utiliza lcd_send_nibble(n) enviando primero nibble alto del byte       //
////////////////////////////////////////////////////////////////////////////////

void lcd_send_byte( byte address, byte n )
{
      lcd_control.rs = 0;
      while ( bit_test(lcd_read_byte(),7) ); //Mientras esté ocupado el LCD, espera
      lcd_control.rs = address;
      delay_cycles(1);
      lcd_control.rw = 0;
      delay_cycles(1);
      lcd_control.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0x0F);
}



/////////////////////////////////////////////////////////////////////////////////////////
// Sitúa el contador de direcciones en la DDRAM (para lectura o escritura posterior)   //
// x puede ir de 1 a 40, posición dentro de una línea (16 visibles)                    //
// y puede ser 1 (línea 1) o 2 (línea 2)                                               //
/////////////////////////////////////////////////////////////////////////////////////////

void lcd_gotoxy( byte x, byte y)
{
   byte posicion;

   if(y!=1)
     posicion=lcd_linea_dos;
   else
     posicion=0;
   posicion+=x-1;
   lcd_send_byte(0,0x80|posicion); //Las direcciones de la DDRAM empiezan por 1xxxxxxx
}



//////////////////////////////////////////////////////////////////////////////////
// Envía un carácter c a la DDRAM del LCD, también algunos caracteres de control//
//////////////////////////////////////////////////////////////////////////////////

void lcd_putc( char c)
{
   switch (c)
   {
     case "f"   : lcd_send_byte(0,1);    //Limpia la pantalla
                   delay_ms(2);
                   break;
     case "
"   : lcd_gotoxy(1,2);       //Coloca puntero en 1ª posicion de la 2ª línea
                   break;
     case ""   : lcd_send_byte(0,0x10); //Retrocede una posición el cursor
                   break;
     case "   "   : lcd_send_byte(0,0x14); //Avanza una posición el cursor
                   break;
     case ""   : lcd_send_byte(0,0x18); //Retrocede una posición la pantalla visible
                   break;
     case "v"   : lcd_send_byte(0,0x1C); //Avanza una posición la pantalla visible
                   break;
     default     : lcd_send_byte(1,c);    //Envía caracter a DDRAM,
                   break;                 //Si es una tira, los envía todos uno a uno
   }
}



////////////////////////////////////////////////////////////////////////////////
// Devuelve el carácter situado en la posición x,y de la DDRAM                //
////////////////////////////////////////////////////////////////////////////////

char lcd_getc( byte x, byte y) {
   char value;

    lcd_gotoxy(x,y);
    lcd_control.rs=1;
    value = lcd_read_byte();
    lcd_control.rs=0;
    return(value);
}



////////////////////////////////////////////////////////////////////////////////////
// Limpia la linea correspondiente y se situa al principio de la misma            //
////////////////////////////////////////////////////////////////////////////////////

void lcd_clr_line(char fila)
{
   int j;

   lcd_gotoxy(1,fila);
    for (j=0;j<40;j++) lcd_putc(" ");

    lcd_gotoxy(1,fila);
}

Un saludo.

[T0ni0]

Por fin funciona!!!!!  


Pues resulta que existian las siguientes diferencias respecto mi placa y la libreria de CCS:

- Los bits de control y de datos estan en un puerto distinto.
- los datos estan en el nibble inferior
- trabajaba con un 18F con un direccionamiento de memoria diferente

Gracias a Pikman por todo, aki esta la librería funcionando:

Codigo:////////////////////////////////////////////////////////////////////////////
////      MODIFICADO PARA USAR CON EL PICDEM2 PORTA A LAS LINEAS        ////
////          DE CONTROL Y EL NIBLE INFERIOR DEL PORTD                  ////
////                     MICROCONTROLADOR 18F452                        ////
////                                                                    ////
////                 Driver for common LCD modules                      ////
////                                                                    ////
////  lcd_init()   Must be called before any other function.            ////
////                                                                    ////
////  lcd_putc(c)  Will display c on the next position of the LCD.      ////
////                     The following have special meaning:            ////
////                      f  Clear display                             ////
////                      
  Go to start of second line                ////
////                        Move back one position                    ////
////                                                                    ////
////  lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1)     ////
////                                                                    ////
////  lcd_getc(x,y)   Returns character at position x,y on LCD          ////
////                                                                    ////
////////////////////////////////////////////////////////////////////////////
////   Systemas MicroInformaticos - Ariel Horas - FEBRERO   2005        ////
////                                                                                               ////
////////////////////////////////////////////////////////////////////////////
// RD0 D4 RD1 D5 RD2 D6 RD3 D7 CONEXION DEL LCD

struct lcd_pin_map {
           Int     data : 4;
           boolean unused;
           boolean unused1;
           boolean unused2;
           boolean unused3;
        } lcd;



   #byte lcd = 0xF83                   // This puts the entire structure
   #define set_tris_lcd(x) set_tris_d(x)


// definicion de lineas de control en porta segun circuito

#define      enable  PIN_A1
#define      rw      PIN_A2
#define      rs      PIN_A3



#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
#define lcd_line_two 0x40    // LCD RAM address for the second line


byte CONST LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};


STRUCT lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
STRUCT lcd_pin_map const LCD_READ =  {15,0,0,0,0}; // For read mode data pins are in



byte lcd_read_byte() {
      byte low,high;
      set_tris_lcd(LCD_READ);
      output_high(rw);
      delay_us(3);
      output_high(enable);
      delay_us(3);
      high = lcd.data;
      output_low(enable);
      delay_us(3);
      output_high(enable);
      delay_us(3);
      low = lcd.data;
      output_low(enable);

      set_tris_lcd(LCD_WRITE);
      return( (high<<4) | low);
}


void lcd_send_nibble( byte n ) {
      lcd.data = n;
      delay_us(3);
      output_high(enable);
      delay_us(2);
      output_low(enable);
}


void lcd_send_byte( byte address, byte n ) {

      output_low(rs);
      while ( bit_test(lcd_read_byte(),7) ) ;
      if(address==1)
           output_high(rs);
       else
      output_low(rs);

      delay_us(3);
      output_low(rw);

      delay_us(3);
      output_low(enable);

      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
}


void lcd_init() {
    byte i;
    set_tris_a(0);

    set_tris_lcd(LCD_WRITE);
    output_low(rs);
    output_low(rw);
    output_low(enable);
    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 "
"   : lcd_gotoxy(1,2);        break;
     case ""   : lcd_send_byte(0,0x10);  break;
     default     : lcd_send_byte(1,c);     break;
   }
}

char lcd_getc( byte x, byte y) {
   char value;

    lcd_gotoxy(x,y);
    output_high(rs);
    value = lcd_read_byte();
    output_low(rs);
    return(value);
}

[Xelene]

Yo tb tengo el picdem2plus xo no hay manera de mandar mensajes al lcd en c

Al programa q más vueltas le he dado es al de oshow, utilicé el su libreria lcd.c y un ejemplo de su página, q compilan perfectamente pero nada... mi lcd no hace nada y no sé porqué...

Tb intenté el de toni0, pero este me da error directamente al compilar... Si alguien lo tiene a ver si me lo puede mandar x email (le dije tb a toni0)...

Nu se...

Saludos!!

[Xelene]

Nada... probe el programita q usó toni0 tb con un 18f452 y nada... tampoco funciona.
He probado el de oshow y el de toni0 (q son practicamente iguales) pero mi lcd se niega a escribir nada y no sé xq puede ser

Lo unico q me funciona es la libreria q viene con la picdem en leguaje de compilador, la he comparado con las otras y no veo nada raro, no se!!!!!!

A ver si alguien le echa un vistazo y se le ocurre algo


#define   LCD_D4      PORTD, 0   ; LCD data bits
#define   LCD_D5      PORTD, 1
#define   LCD_D6      PORTD, 2
#define   LCD_D7      PORTD, 3

#define   LCD_D4_DIR   TRISD, 0   ; LCD data bits
#define   LCD_D5_DIR   TRISD, 1
#define   LCD_D6_DIR   TRISD, 2
#define   LCD_D7_DIR   TRISD, 3

#define   LCD_E      PORTA, 1   ; LCD E clock
#define   LCD_RW      PORTA, 2   ; LCD read/write line
#define   LCD_RS      PORTA, 3   ; LCD register select line

#define   LCD_E_DIR   TRISA, 1   
#define   LCD_RW_DIR   TRISA, 2   
#define   LCD_RS_DIR   TRISA, 3   

#define   LCD_INS      0   
#define   LCD_DATA   1

D_LCD_DATA   UDATA 0x20
COUNTER      res   1
delay      res   1
temp_wr      res   1
temp_rd      res   1

   GLOBAL   temp_wr

PROG1   CODE

;****************************************************************
LCDLine_1
   banksel   temp_wr
   movlw   0x80
   movwf   temp_wr
   call   i_write
   return
   GLOBAL   LCDLine_1

LCDLine_2
   banksel   temp_wr
   movlw   0xC0
   movwf   temp_wr
   call   i_write
   return
   GLOBAL   LCDLine_2
   
d_write               ;write data
   call   LCDBusy
   bsf   STATUS, C   
   call   LCDWrite
   banksel   TXREG         ;move data into TXREG
   movwf   TXREG
   banksel   TXSTA
   btfss   TXSTA,TRMT      ;wait for data TX
   goto   $-1
   banksel   PORTA   
   return
   GLOBAL   d_write
   
i_write               ;write instruction
   call   LCDBusy
   bcf   STATUS, C
   call   LCDWrite
   return
    GLOBAL   i_write

rlcd   macro   MYREGISTER
 IF MYREGISTER == 1
   bsf   STATUS, C
   call   LCDRead
 ELSE
   bcf   STATUS, C
   call   LCDRead
 ENDIF
   endm
;****************************************************************
LCDInit
   clrf   PORTA
   
   banksel   TRISA         ;configure control lines
   bcf   LCD_E_DIR
   bcf   LCD_RW_DIR
   bcf   LCD_RS_DIR
   
   movlw   b"00001110"
   banksel   ADCON1
   movwf   ADCON1   

   movlw   0xff         ; Wait ~15ms @ 20 MHz
   banksel   COUNTER
   movwf   COUNTER
   movlw   0xFF
   banksel   delay
   movwf   delay
   call   DelayXCycles
   decfsz   COUNTER, F
   goto   $-3
   
   movlw   b"00110000"      ;#1 Send control sequence
   movwf   temp_wr
   bcf   STATUS,C
   call   LCDWriteNibble

   movlw   0xff         ;Wait ~4ms @ 20 MHz
   movwf   COUNTER
   movlw   0xFF
   movwf   delay
   call   DelayXCycles
   decfsz   COUNTER, F
   goto   $-3

   movlw   b"00110000"      ;#2 Send control sequence
   movwf   temp_wr
   bcf   STATUS,C
   call   LCDWriteNibble

   movlw   0xFF         ;Wait ~100us @ 20 MHz
   movwf   delay
   call   DelayXCycles
                  
   movlw   b"0011000"      ;#3 Send control sequence
   movwf   temp_wr
   bcf   STATUS,C
   call   LCDWriteNibble

      ;test delay
   movlw   0xFF         ;Wait ~100us @ 20 MHz
   movwf   delay
   call   DelayXCycles


   movlw   b"00100000"      ;#4 set 4-bit
   movwf   temp_wr
   bcf   STATUS,C
   call   LCDWriteNibble

   call   LCDBusy         ;Busy?
            
   movlw   b"00101000"      ;#5   Function set
   movwf   temp_wr
   call   i_write

   movlw   b"00001101"      ;#6  Display = ON
   movwf   temp_wr
   call   i_write
         
   movlw   b"00000001"      ;#7   Display Clear
   movwf   temp_wr
   call   i_write

   movlw   b"00000110"      ;#8   Entry Mode
   movwf   temp_wr
   call   i_write   

   movlw   b"10000000"      ;DDRAM addresss 0000
   movwf   temp_wr
   call   i_write

;   movlw   b"00000010"      ;return home
;   movwf   temp_wr
;   call   i_write


   return

   GLOBAL   LCDInit   
;*****************************************************************
;     _    ______________________________
; RS  _>--<______________________________
;     _____
; RW       \_____________________________
;                  __________________
; E   ____________/                  \___
;     _____________                ______
; DB  _____________>--------------<______
;
LCDWriteNibble
   btfss   STATUS, C      ; Set the register select
   bcf   LCD_RS
   btfsc   STATUS, C   
   bsf   LCD_RS

   bcf   LCD_RW         ; Set write mode

   banksel   TRISD
   bcf   LCD_D4_DIR      ; Set data bits to outputs
   bcf   LCD_D5_DIR
   bcf   LCD_D6_DIR
   bcf   LCD_D7_DIR

   NOP            ; Small delay
   NOP

   banksel   PORTA
   bsf   LCD_E         ; Setup to clock data
   
   btfss   temp_wr, 7         ; Set high nibble
   bcf   LCD_D7   
   btfsc   temp_wr, 7
   bsf   LCD_D7
   btfss   temp_wr, 6
   bcf   LCD_D6   
   btfsc   temp_wr, 6
   bsf   LCD_D6
   btfss   temp_wr, 5
   bcf   LCD_D5   
   btfsc   temp_wr, 5
   bsf   LCD_D5
   btfss   temp_wr, 4
   bcf   LCD_D4
   btfsc   temp_wr, 4
   bsf   LCD_D4   

   NOP
   NOP

   bcf   LCD_E         ; Send the data

   return
; ****************************************************************
LCDWrite
;   call   LCDBusy
   call   LCDWriteNibble
   BANKSEL   temp_wr
   swapf   temp_wr, f
   call   LCDWriteNibble
   banksel   temp_wr
   swapf   temp_wr,f

   return

   GLOBAL   LCDWrite

; ****************************************************************
;     _____    _____________________________________________________
; RS  _____>--<_____________________________________________________
;               ____________________________________________________
; RW  _________/
;                  ____________________      ____________________
; E   ____________/                    \____/                    \__
;     _________________                __________                ___
; DB  _________________>--------------<__________>--------------<___
;
LCDRead
   banksel   TRISD
   bsf   LCD_D4_DIR      ; Set data bits to inputs
   bsf   LCD_D5_DIR
   bsf   LCD_D6_DIR
   bsf   LCD_D7_DIR      

   BANKSEL   PORTA
   btfss   STATUS, C      ; Set the register select
   bcf   LCD_RS
   btfsc   STATUS, C   
   bsf   LCD_RS

   bsf   LCD_RW         ;Read = 1

   NOP
   NOP         

   bsf   LCD_E         ; Setup to clock data

   NOP
   NOP
   NOP
   NOP

   btfss   LCD_D7         ; Get high nibble
   bcf   temp_rd, 7
   btfsc   LCD_D7
   bsf   temp_rd, 7
   btfss   LCD_D6         
   bcf   temp_rd, 6
   btfsc   LCD_D6
   bsf   temp_rd, 6
   btfss   LCD_D5         
   bcf   temp_rd, 5
   btfsc   LCD_D5
   bsf   temp_rd, 5
   btfss   LCD_D4         
   bcf   temp_rd, 4
   btfsc   LCD_D4
   bsf   temp_rd, 4

   bcf   LCD_E         ; Finished reading the data

   NOP
   NOP
   NOP
   NOP
   NOP
   NOP
   NOP
   NOP

   bsf   LCD_E         ; Setup to clock data

   NOP
   NOP

   btfss   LCD_D7         ; Get low nibble
   bcf   temp_rd, 3
   btfsc   LCD_D7
   bsf   temp_rd, 3
   btfss   LCD_D6         
   bcf   temp_rd, 2
   btfsc   LCD_D6
   bsf   temp_rd, 2
   btfss   LCD_D5         
   bcf   temp_rd, 1
   btfsc   LCD_D5
   bsf   temp_rd, 1
   btfss   LCD_D4         
   bcf   temp_rd, 0
   btfsc   LCD_D4
   bsf   temp_rd, 0

   bcf   LCD_E         ; Finished reading the data

FinRd
   return
; ****************************************************************
LCDBusy
               ; Check BF
   rlcd   LCD_INS
   btfsc   temp_rd, 7
   goto   LCDBusy
   return

   GLOBAL   LCDBusy

; ****************************************************************
DelayXCycles
   decfsz   delay, F
   goto   DelayXCycles
   return
; ****************************************************************
   END

[pikman]

Xelene, el driver que pego T0nio, no es para usar con el compilador de CCS, a pesar de ser C no es portable a otros compiladores tal como esta, el codigo funciona correctamente, y es para PIC18, solamente si lo quieres usar en PIC16 deberas modificar la direccion de los puertos, dejame sabes que compilador usas y veo como te ayudo, probablemente o sea una version de CCS antigua.

saludos

ARIEL
 

[Xelene]

Holas pikman, utilizo CCS y la version es 3.43.

Aunq normalmente uso un 16f877, tengo un 18f452 y le pedí a tonio q me enviara la libreria con un ejemplito sencillo para saber si funcionaba o no... Utilizo el mplab con el plug in de ccs, compila y todo bien, pero no funciona, la lcd no muestra nada.

No se si necesitas algun dato más, gracias x ayudarme!!

[T0ni0]

Holas, creo que tendrias de asegurarte que version tienes del CCS yo tengo la 3.215 y con esa si que va bien seguramente sera eso. porque el ejemplo que te envie va bien con la PICDEM2+ y 18F452  

[Xelene]

Tienes razón toni0, hice un apaño con unos cables para poder programar un 16f84 con el icprog para utilizar la pantalla el lcd y efectivamente funcionaba (bueno, el tuyo no probé, probé el de oshow, pero viene a ser lo mismo). Bajaré la versión q dices xq está claro q el problema está en el compilador. A ver si asi lo soluciono ya definitivamente.

Gracias a todos y ya os contaré.

Saludos, Maria.