libreria en CCS para el manejo del LCD HITACHI HD44780 usada en modo 4bits de datos

[nordestenica]

pues esso busco una libreria en CCS para el manejo del LCD  HITACHI HD44780 usada en modo 4bits de datos e no encuentro nada que me sirva ademas que quiero conectar RW- RB3 O GND     RS-RB2 O RA1    ENABLE-RB1 O RA4    las lineas de datos normales de RB4-RB7 O RC0-RC3

[Nocturno]

Hace poco estuve buscando alguna librería que permitiera esa flexibilidad y encontré varias. Finalmente, la que más me gustó es la que te pego a continuación:

Codigo:// La ventaja de este codigo es que puedes trabajar si lo quieres con pines
// dispersos es decicir no estas sujeto a la mitad de un puerto


// Registros de Puertos A & B
#define PORTA 0x05 // Puerto A
#define PORTB 0x06 // Registro de direccionamiento Puerto A
#define TRISA 0x85 // Puerto B
#define TRISB 0x86 // Registro de direccionamiento Puerto B
#define PORTD 0xF83 // Registro de direccionamiento Puerto A
#define TRISD 0xF95 // Puerto B


// Definición de Puertos Pantalla LCD 40x20 Hitachi 44780
#bit lcd_db4 = PORTD.4
#bit tris_lcd_db4 = TRISD.4
#bit lcd_db5 = PORTD.5
#bit tris_lcd_db5 = TRISD.5
#bit lcd_db6 = PORTD.6
#bit tris_lcd_db6 = TRISD.6
#bit lcd_db7 = PORTD.7
#bit tris_lcd_db7 = TRISD.7
#bit lcd_en = PORTD .0
#bit tris_lcd_en = TRISD.0
#bit lcd_rw = PORTD.2
#bit tris_lcd_rw = TRISD.2
#bit lcd_rs = PORTD.1
#bit tris_lcd_rs = TRISD.1


// lcd_init() Inicialización del LCD (debe utilizarse al principio,
// antes de trabajar con el LCD).
//
// lcd_putc(c) Imprime un caracter en el LCD.
//
// lcd_gotoxy(x,y) Selecciona la nueva posicion de escritura en el LCD.
// (la esquina superior izquierda es 1,1)
//
// lcd_getc(x,y) Devuelve el caracter de la posicion x,y del LCD.
//
// void lcd_erase_line(x) Borra una cantidad de caracter hacia la derecha

// Conexion a la pantalla LCD 40x4
// RB0 <---> LCD DB4
// RB1 <---> LCD DB5
// RB2 <---> LCD DB6
// RB3 <---> LCD DB7
// RA0 <---> LCD ENEABLE
// RA1 <---> LCD R/W
// RA2 <---> LCD RS
//

#define LCD_DATO 1
#define LCD_INST 0

#define LCD_LINEA1 0x80 // Direccion de memoria para la 1 linea
#define LCD_LINEA2 0xc0 // Direccion de memoria para la 2 linea
#define LCD_LINEA3 0x94 // Direccion de memoria para la 3 linea
#define LCD_LINEA4 0xd4 // Direccion de memoria para la 4 linea

#define chr_1 0x00
#define chr_2 0x01
#define chr_3 0x02
#define chr_4 0x03
#define chr_5 0x04
#define chr_6 0x05
#define chr_7 0x06

// 7 6 5 4 3 2 1 0
// Function Set 0b 0 0 1 B L F 0 0
// Bus size, B:0=4 bits, B:1=8 bits
// Line Number, L:0=1 Line, L:1=2 Lines
// Font size F:0=5x8, F:1=5x10
#define LCD_FUNCTION_SET 0b00101000 // Bus=4bit, Line=2 & Font=5x8

// 7 6 5 4 3 2 1 0
// Display/Cursor 0b 0 0 0 0 1 D U B
// Set Display on/off, D:0=off, D:1=on
// Underline cursor, U:0=off, U:1=on
// Blinking cursor, B:0=off, B:1=on
#define LCD_DISPLAY_CURSOR 0b00001100 // Display=on, Scroll=off, Blinkin=off

// 7 6 5 4 3 2 1 0
// Entry Mode 0b 0 0 0 0 0 1 M S
// Cursor direction, M:0=left, 1=right
// Display Scroll, S:0=no scroll, S:1=scroll
#define LCD_ENTRY_MODE 0b00000110 // Increment cursor, no disp shift

void lcd_set_write() {
tris_lcd_db4 = 0; //
tris_lcd_db5 = 0; //
tris_lcd_db6 = 0; //
tris_lcd_db7 = 0; //---> Set portb RB0-RB3 mode output
}

void lcd_set_read() {
tris_lcd_db4 = 1; //
tris_lcd_db5 = 1; //
tris_lcd_db6 = 1; //
tris_lcd_db7 = 1; //---> Set portb RB0-RB3 mode input
}

int8 lcd_read() {
int8 valor=0; // Crea e inicializa una variable de 8 Bits
lcd_set_read(); // Prepara el puerto DB4-DB7 como entrada
lcd_rw = 1; // Habilita modo de lectura
delay_cycles(1); // nop
lcd_en = 1; // Habilita LCD Eneable
delay_cycles(1); // nop
if (lcd_db4) // Lectura de DB4
bit_set(valor,4); //
if (lcd_db5) // Lectura de DB5
bit_set(valor,5); //
if (lcd_db6) // Lectura de DB6
bit_set(valor,6); //
if (lcd_db7) // Lectura de DB7
bit_set(valor,7); //---> Recoje los datos MSB
lcd_en = 0; // Desabilita LCD Eneable
delay_cycles(1); // nop
lcd_en = 1; // Habilita LCD Eneable
delay_us(2); // Espera 2 uSeg.
if (lcd_db4) //
bit_set(valor,0); //
if (lcd_db5) //
bit_set(valor,1); //
if (lcd_db6) //
bit_set(valor,2); //
if (lcd_db7) //
bit_set(valor,3); //---> Recoje los datos LSB
lcd_en = 0; // Desabilita LCD Eneable
delay_cycles(1); // nop
lcd_set_write(); // Prepara el puerto DB4-DB7 como salida
return (valor);
}

void lcd_send_nibble(int8 n) {
if (bit_test(n,0)) //
lcd_db4 = 1; //
else //
lcd_db4 = 0; //

if (bit_test(n,1)) //
lcd_db5 = 1; //
else //
lcd_db5 = 0; //

if (bit_test(n,2)) //
lcd_db6 = 1; //
else //
lcd_db6 = 0; //

if (bit_test(n,3)) //
lcd_db7 = 1; //
else //
lcd_db7 = 0; //---> Set data nibble
delay_cycles(1); // nop
lcd_en = 1; // Habilita LCD Eneable __
delay_us(2); // Espera 2 uSeg. | |
lcd_en = 0; // Desabilita LCD Eneable __| |__
}

void lcd_send_byte (int1 select, int8 n) {
lcd_rs = 0; // Modo de instruccion
while (bit_test(lcd_read(),7)); // Espera que la pantalla se desabilite
lcd_rs = select; // Escoje entre RS=0 : Instruccion & RS=1 : Data
delay_cycles(1); // nop
lcd_rw = 0; // Habilita modo de escritura
delay_cycles(1); // nop
lcd_en = 0; // Desabilita LCD Eneable
lcd_send_nibble(n >> 4); // Envia los datos superiores MSB
lcd_send_nibble(n); // Envia los datos inferiores LSB
}


// Opciona por si quieres crear caracteres especiales, puedes crear hasta 8
void lcd_cgram() {
int8 i;
const int8 chr[56] = {0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x15, // chr_1
0x15,0x00,0x10,0x10,0x10,0x10,0x00,0x15, // chr_2
0x15,0x00,0x14,0x14,0x14,0x14,0x00,0x15, // chr_3
0x15,0x00,0x15,0x15,0x15,0x15,0x00,0x15, // chr_4
0x00,0x00,0x00,0x00,0x1F,0x0E,0x04,0x00, // chr_5
0x00,0x04,0x0E,0x1F,0x04,0x04,0x04,0x00, // chr_6
0x00,0x04,0x04,0x04,0x1F,0x0E,0x04,0x00}; // chr_7

lcd_send_byte(LCD_INST, 0x40);
for(i=0;i<=55;++i) {
lcd_send_byte(LCD_DATO, chr);
}
lcd_send_byte(LCD_INST,0x01); // Clear LCD
}

void lcd_init() {
int8 i, count=0;
lcd_set_write(); // Prepara el puerto DB4-DB7 como salida
tris_lcd_en = 0; //
tris_lcd_rw = 0; //
tris_lcd_rs = 0; //---> Set porta RA0, RA1 & RA2 mode output
lcd_en = 0; //
lcd_rw = 0; //
lcd_rs = 0; //---> Clear LCD_EN, LCD_RW & LCD_RS
delay_ms(25);
retry:
for(i=1; i<=3; ++i) {
lcd_send_nibble(0b0011); // 8 bit mode 3 times
delay_ms(5);
}
lcd_send_nibble(0b0010); // 4 bit mode
while (bit_test(lcd_read(),7)) { // Espera que la pantalla se desabilite
delay_us(100);
count++;
if (count>=200) {
count=0;
goto retry;
}
}
lcd_send_byte(LCD_INST, LCD_FUNCTION_SET); // Function Set
lcd_send_byte(LCD_INST, LCD_DISPLAY_CURSOR); // Display Cursor
lcd_send_byte(LCD_INST, LCD_ENTRY_MODE); // Entry Mode
}

void lcd_gotoxy(int8 x, int8 y) {
int8 const address[4]={LCD_LINEA1,LCD_LINEA2,LCD_LINEA3,LCD_LINEA4};
int8 pos;
pos=address[y-1]+(x-1);
lcd_send_byte (LCD_INST, pos);
}

char lcd_getc(int8 x, int8 y) {
char valor;
lcd_gotoxy(x,y);
lcd_rs = 1;
valor = lcd_read();
lcd_rs = 0;
return (valor);
}

/*void lcd_putc(char c) {
lcd_send_byte(LCD_DATO,c);
}*/

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(LCD_DATO,c);     break;
   }
}

void lcd_clear() {
lcd_send_byte(LCD_INST,0x01);
}

void lcd_home() {
lcd_send_byte(LCD_INST,0x02);
}

void lcd_erase_line(int8 x) {
int8 i;
for(i=1;i<=x;++i) {
lcd_send_byte(LCD_DATO,32);
}
}

[nordestenica]

me estoi volviendo loco com esto aver

esto seria si conectara las lineas de datos desde B4-B7 e las lineas de control en el puerto A para una lcd 2x16 no ay nada mas que alterar correcto

LCD.c

#bit lcd_db4 = PORTB.4
#bit tris_lcd_db4 = TRISB.4
#bit lcd_db5 = PORTB.5
#bit tris_lcd_db5 = TRISB.5
#bit lcd_db6 = PORTB.6
#bit tris_lcd_db6 = TRISB.6
#bit lcd_db7 = PORTB.7
#bit tris_lcd_db7 = TRISB.7
#bit lcd_en = PORTA .0
#bit tris_lcd_en = TRISA.0
#bit lcd_rw = PORTA.2
#bit tris_lcd_rw = TRISA.2
#bit lcd_rs = PORTA.1
#bit tris_lcd_rs = TRISA.1

esto seria el codigo para testeo

#include <16f84.h>

#use delay(clock=4000000)

#include <LCD.c>
main()
{

    lcd_init();       
    lcd_putc("NORDESTECNICA";
    lcd_gotoxy(6,2);
    lcd_putc("LCD HD44780 2x16";
    delay_ms(1000);

}


assi deveria funcionar no pues nada ni en proteus ni en la protobord

[Nocturno]

Yo he probado la librería en un LCD 4x40, no sé si te iba a funcionar bien en un 2x16.

[nordestenica]

esto sigue sin funcionar aver

aqui definimos el puerto e el registro de direcionamento para el puerto B
#define TRISA 0x85 // Puerto B
#define TRISB 0x86 // Registro de direccionamiento Puerto B



aqui los pines que vamos a usar
#bit lcd_en = PORTB.0 // enable del lcd lo conectamos a B0//
#bit tris_lcd_en = TRISB.0
#bit lcd_rs = PORTB.1  // RS del lcd lo conectamos a B1//
#bit tris_lcd_rs = TRISB.1
#bit lcd_db4 = PORTB.2    // LINEA DE DATOS D4 DE LA LCD A B2 DEL PIC E ASI ASTA D7 DE LA LCD A B5 DEL PIC //
#bit tris_lcd_db4 = TRISB.2
#bit lcd_db5 = PORTB.3
#bit tris_lcd_db5 = TRISB.3
#bit lcd_db6 = PORTB.4
#bit tris_lcd_db6 = TRISB.4
#bit lcd_db7 = PORTB.5
#bit tris_lcd_db7 = TRISB.5


no ay mas alteraciones a acer verdade es que probado en proteus con um 18f258 e varios de la serie 18 e va perfecto pero quando quiero usar la libreria en un 16f628 o otro de la serie 16 no va

[nordestenica]

otra vez yo dando la lata es que quanto mas leo e miro menos se aver si me ayudais con esto e encontrado esta libreria que creo que me serviria pero tengo que canbiar la asignacion de pines e no lo veo claro

las lineas de datos tengo que conectarlas a RB4 RB5 RB6 RB7 O RC0 RC1 RC2 RC3
las lineas de control R/W A RB3 O GND  RS A RB2 O RA1  E ENABLE A RB1 O RA4






////////////////////////////////////////////////////////////////////////////
////                             LCD_MOD.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
//     RC0  enable
//     RC1  rw
//     RC2  rs
//
//    Líneas de Datos
//     RB0  D4
//     RB1  D5
//     RB2  D6
//     RB3  D7
//
//

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

           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
           boolean nada;   // 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 =6               // Lo mismo para los datos, en el PORTB (registro 6)
#byte trisb = 0x86               // 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 posteriores

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&=0b11111000; // Asignamos salidas en RC0, RC1 y RC2, resto puerto como estaba
      trisa&=0b00000000;

    trisb&=0b11110000; // Lo mismo para RB0 a RB3

    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,0b00001101); ///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&=0b11111000; //Las señales de control siguen siendo salidas, el resto lo que sean
      trisb|=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;

      trisb&=0b11110000; // Dejamos Rb0 a Rb3 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) o 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);
}