EDICION DE LIBRERIAS CCS

[mario_pastor]

Saludos amigos, desde aquí podemos hacer preguntas sobre cómo modificar las librerías del compilador CCS para adaptarlas a nuestras aplicaciones.

Bueno hago la primera pregunta cómo modificar la librería LCD.C para poder usarla con la siguiente configuración:

     A0  enable
     A1  rw
     A2  rs
     B4  D4
     B5  D5
     B6  D6
     B7  D7

Intenté hacerlo pero no entiendo muchas cosas  como para que es el STRUCT, BOOLEAN, #if defined(__PCH__)... esto puede ser muy elemental, pero recién inicio en este mundo  pido ayuda a los GURUS del C

[vszener]

Ke tal!!!bien yo la verdad que no me puesto hacer una libreria de manejo de lcd ya que creo que es perder el tiempo, perder el tiempo ya que hay miles ya realizadas y es mejor emplear el tiempo en cosas no realizadas aun....asi que te dejo aqui el enlace a un post del foro de CCS donde hablan d euna libreria flexible para manejo de lcd, aqui el enlace:
http://www.ccsinfo.com/forum/viewtopic.php?t=24661
Y aqui te dejo la libreria:

// flex_lcd.c

// These pins are for the Microchip PicDem2-Plus board,
// which is what I used to test the driver.  Change these
// pins to fit your own board.

#define LCD_DB4   PIN_D0
#define LCD_DB5   PIN_D1
#define LCD_DB6   PIN_D2
#define LCD_DB7   PIN_D3

#define LCD_E     PIN_A1
#define LCD_RS    PIN_A3
#define LCD_RW    PIN_A2

// If you only want a 6-pin interface to your LCD, then
// connect the R/W pin on the LCD to ground, and comment
// out the following line.

#define USE_LCD_RW   1      

//========================================

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


int8 const LCD_INIT_STRING[4] =
{
 0x20 | (lcd_type << 2), // Func set: 4-bit, 2 lines, 5x8 dots
 0xc,                    // Display on
 1,                      // Clear display
 6                       // Increment cursor
 };
                             

//-------------------------------------
void lcd_send_nibble(int8 nibble)
{
// Note:  !! converts an integer expression
// to a boolean (1 or 0).
 output_bit(LCD_DB4, !!(nibble & 1));
 output_bit(LCD_DB5, !!(nibble & 2));  
 output_bit(LCD_DB6, !!(nibble & 4));    
 output_bit(LCD_DB7, !!(nibble & );    

 delay_cycles(1);
 output_high(LCD_E);
 delay_us(2);
 output_low(LCD_E);
}

//-----------------------------------
// This sub-routine is only called by lcd_read_byte().
// It"s not a stand-alone routine.  For example, the
// R/W signal is set high by lcd_read_byte() before
// this routine is called.      

#ifdef USE_LCD_RW
int8 lcd_read_nibble(void)
{
int8 retval;
// Create bit variables so that we can easily set
// individual bits in the retval variable.
#bit retval_0 = retval.0
#bit retval_1 = retval.1
#bit retval_2 = retval.2
#bit retval_3 = retval.3

retval = 0;
   
output_high(LCD_E);
delay_cycles(1);

retval_0 = input(LCD_DB4);
retval_1 = input(LCD_DB5);
retval_2 = input(LCD_DB6);
retval_3 = input(LCD_DB7);
 
output_low(LCD_E);
   
return(retval);    
}    
#endif

//---------------------------------------
// Read a byte from the LCD and return it.

#ifdef USE_LCD_RW
int8 lcd_read_byte(void)
{
int8 low;
int8 high;

output_high(LCD_RW);
delay_cycles(1);

high = lcd_read_nibble( );

low = lcd_read_nibble( );

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

//----------------------------------------
// Send a byte to the LCD.
void lcd_send_byte(int8 address, int8 n)
{
output_low(LCD_RS);

#ifdef USE_LCD_RW
while(bit_test(lcd_read_byte( ),7) ) ;
#else
delay_us(60);  
#endif

if(address)
   output_high(LCD_RS);
else
   output_low(LCD_RS);
     
 delay_cycles(1);

#ifdef USE_LCD_RW
output_low(LCD_RW);
delay_cycles(1);
#endif

output_low(LCD_E);

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

//----------------------------
void lcd_init(void)
{
int8 i;

output_low(LCD_RS);

#ifdef USE_LCD_RW
output_low(LCD_RW);
#endif

output_low(LCD_E);

delay_ms(15);

for(i=0 ;i < 3; i++)
   {
    lcd_send_nibble(0x03);
    delay_ms(5);
   }

lcd_send_nibble(0x02);

for(i=0; i < sizeof(LCD_INIT_STRING); i++)
   {
    lcd_send_byte(0, LCD_INIT_STRING[ i ] );
   
    // If the R/W signal is not used, then
    // the busy bit can"t be polled.  One of
    // the init commands takes longer than
    // the hard-coded delay of 60 us, so in
    // that case, lets just do a 5 ms delay
    // after all four of them.
    #ifndef USE_LCD_RW
    delay_ms(5);
    #endif
   }

}

//----------------------------

void lcd_gotoxy(int8 x, int8 y)
{
int8 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;
   }
}

//------------------------------
#ifdef USE_LCD_RW
char lcd_getc(int8 x, int8 y)
{
char value;

lcd_gotoxy(x,y);

// Wait until busy flag is low.
while(bit_test(lcd_read_byte(),7) );  

output_high(LCD_RS);
value = lcd_read_byte( );
output_low(lcd_RS);

return(value);
}
#endif

Yo esta no la he probado....de todas formas si quieres una libreria de 8bits en el ejemplo 37 y 37 del post ejemplios en c se trabaja con libreria de manejo de lcd de 8bits y el control en el porta, aqui el enlace a el post de ejemplitos:
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4061462

Suerte!!!

[mario_pastor]

Muchas gracias vszener, es justamente lo que tenía en mente... ya que algunas aplicaciones no siempre permiten que el LCD quede en un mismo puerto y de esa manera usar la que viene por default en el CCS. Ahora me pondre a estudiarla ya estaré molestandote una vez más

[garlic_74]

que ventajas tiene usar el lcd en modo 8 bits?

un saludo

[jfh900]

La unica ventaja que tiene es la velocidad, ya que al ser el puerto de 8 bits con una sola lectura/escritura trasnfieres todo el byte y con 4 bits necesitas dos ciclos de lectura escritura. Por lo demas funciona exactamente igual.

[vszener]

Buenas!!!bien la ventaja de su uso de 8bits es la rapidez es el doble de rapida de la libreria de 4bits....su desventaja es que usa 8 pines de la lcd....

[pocher]

Lo prometido es deuda, aunque siempre con retraso...

 

Codigo:
//include LCD para CCS

// La ventaja de este codigo es que puedes trabajar si lo quieres con pines
// dispersos es decir no estas sujeto a la mitad de un puerto. Además no se usa el pin R/W,
// se conecta a masa

// 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 PORTC 0x07 // Registro de direccionamiento Puerto C
#define TRISC 0x87 // Puerto C

// Definición de Puertos Pantalla LCD 40x20 Hitachi 44780

/*
#bit lcd_db4 = PORTC.0
#bit tris_lcd_db4 = TRISC.0
#bit lcd_db5 = PORTC.1
#bit tris_lcd_db5 = TRISC.1
#bit lcd_db6 = PORTC.2
#bit tris_lcd_db6 = TRISC.2
#bit lcd_db7 = PORTC.3
#bit tris_lcd_db7 = TRISC.3

#bit lcd_en = PORTC.5
#bit tris_lcd_en = TRISC.5
#bit lcd_rs = PORTC.4
#bit tris_lcd_rs = TRISC.4
*/

#bit lcd_db4 = PORTB.0
#bit tris_lcd_db4 = TRISB.0
#bit lcd_db5 = PORTB.1
#bit tris_lcd_db5 = TRISB.1
#bit lcd_db6 = PORTC.0
#bit tris_lcd_db6 = TRISC.0
#bit lcd_db7 = PORTC.1
#bit tris_lcd_db7 = TRISC.1

#bit lcd_en = PORTA.0
#bit tris_lcd_en = TRISA.0
#bit lcd_rs = PORTA.2
#bit tris_lcd_rs = TRISA.2


// 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
// RC0 <---> LCD DB4
// RC1 <---> LCD DB5
// RC2 <---> LCD DB6
// RC3 <---> LCD DB7
// RC5 <---> LCD ENABLE
// RC4 <---> 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



// 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_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(5); // nop
lcd_en = 1; // Habilita LCD Eneable __
delay_us(20); // Espera 2 uSeg. | |
lcd_en = 0; // Desabilita LCD Eneable __| |__
}

void lcd_send_byte (int1 select, int8 n) {
lcd_rs = 0; // Modo de instruccion
lcd_rs = select; // Escoje entre RS=0 : Instruccion & RS=1 : Data
delay_cycles(5); // 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
}

void lcd_init() {
int8 i, count=0;
lcd_set_write(); // Prepara el puerto DB4-DB7 como salida
tris_lcd_en = 0; //
tris_lcd_rs = 0; //---> Set porta RA0, RA1 & RA2 mode output
lcd_en = 0; //
lcd_rs = 0; //---> Clear LCD_EN, LCD_RW & LCD_RS
delay_ms(100);
retry:
for(i=1; i<=3; ++i) {
lcd_send_nibble(0b0011); // 8 bit mode 3 times
delay_ms(30);
}
lcd_send_nibble(0b0010); // 4 bit mode
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);
}


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

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

Un saludo