Autor Tema: Desmenuzar un drivers de LCD - CCS (Leído 10448 veces)

pajaro · « **en:** 21 de Agosto de 2009, 13:38:51 »

hola amigos

Cuando quieres crear o modificar un drivers de lcd lo primero que te planteas es desmenuzar un drivers ya echo ,saber lo que hace cada parte y como añadirle cosas, si ademas esta comentado pues mejor.

Me gustaria que los coladoradores y seres supremos y otros entes de este foro me echaran un capote, aunque es verano,.. alguno pillaremos aburrido en casa.

Partiremos del driver de CCS asi que empezaremos:

- Que un driver

Que es un DRIVER o CONTROLADOR.

Es un documento escrito en lenguaje de programacion en alto o bajo nivel, con estensión propia en nuestro caso .C o .H dentro del cual se encuentra definidas las entradas y salidas de un dipositivo electronico o un moulo electronico, puede estar codificado o no.

Este trocito de programa tambien contendra como debe responder ante ciertos estimulo el dispositico y que comportaminetos se beben de adoptar.

Para su uso la libreria suele acompañar de una funciones basicas implementadas por el fabricante en algunos casos y en otras por desarrolladores o implementadores, estas funciones de forma particular son muchas veces ampliadas por usuarios, llegando a perderse si no se dan a conocer.

- para que vale

Cual es el uso de estos controladores.

Un driver técnicamente es un software o programa que sirve de intermediario entre un dispositivo de hardware y el sistema operativo.
En nuestro caso sera sera una libreria en .C o .H en la cual estara definido el dipositivo a controlar y algunas funciones para facilitar su manejo.

- Estandarizacion

LA estandarizacion.

La estandarización de un dispositivo o controlador tiene sus ventajas, ya que el uso del mismo lo hacen muchos usuarios y es facil probar sus fallas y sus mejoras estan dispuestas a disposicion de más cabecitas pensantes.

drivers

LCD.c
LCD420.c
flex.c

LCD_01
LCD_02
LCD_03
LCD_04
LCD_05

#Funciones de uso incorporadas en el drivers.

#Mejoras

#Enlaces de interes.

#Driver g

#enlaces preferentes

libreria full LCD para CCS http://www.todopic.com.ar/foros/index.php?topic=24085.msg195373#msg195373
http://www.todopic.com.ar/foros/index.php?topic=24085.20

pajaro · « **Respuesta #1 en:** 21 de Agosto de 2009, 13:39:41 »

LCD 16x2 (CCS)

Libreria Original

Código: CSS

///////////////////////////////////////////////////////////////////////////////
////                             LCD.C                                     ////
////                 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                                ////
////                      \n  Go to start of second line                   ////
////                      \b  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             ////
////                                                                       ////
////  CONFIGURATION                                                        ////
////  The LCD can be configured in one of two ways: a.) port access or     ////
////  b.) pin access.  Port access requires the entire 7 bit interface     ////
////  connected to one GPIO port, and the data bits (D4:D7 of the LCD)     ////
////  connected to sequential pins on the GPIO port.  Pin access           ////
////  has no requirements, all 7 bits of the control interface can         ////
////  can be connected to any GPIO using several ports.                    ////
////                                                                       ////
////  To use port access, #define LCD_DATA_PORT to the SFR location of     ////
////  of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP    ////
////  of this file to configure the pin order.  If you are using a         ////
////  baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must  ////
////  be defined.                                                          ////
////                                                                       ////
////  Example of port access:                                              ////
////     #define LCD_DATA_PORT getenv("SFR:PORTD")                         ////
////                                                                       ////
////  To use pin access, the following pins must be defined:               ////
////     LCD_ENABLE_PIN                                                    ////
////     LCD_RS_PIN                                                        ////
////     LCD_RW_PIN                                                        ////
////     LCD_DATA0                                                         ////
////     LCD_DATA1                                                         ////
////     LCD_DATA2                                                         ////
////     LCD_DATA3                                                         ////
////     LCD_DATA4                                                         ////
////                                                                       ////
////  Example of pin access:                                               ////
////     #define LCD_ENABLE_PIN  PIN_E0                                    ////
////     #define LCD_RS_PIN      PIN_E1                                    ////
////     #define LCD_RW_PIN      PIN_E2                                    ////
////     #define LCD_DATA0       PIN_D4                                    ////
////     #define LCD_DATA1       PIN_D5                                    ////
////     #define LCD_DATA2       PIN_D6                                    ////
////     #define LCD_DATA3       PIN_D7                                    ////
////                                                                       ////
///////////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2009 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.                               ////
///////////////////////////////////////////////////////////////////////////
 
typedef struct  
{                            // This structure is overlayed
   BOOLEAN enable;           // on to an I/O port to gain
   BOOLEAN rs;               // access to the LCD pins.
   BOOLEAN rw;               // The bits are allocated from
   BOOLEAN unused;           // low order up.  ENABLE will
   int     data : 4;         // be LSB pin of that port.
  #if defined(__PCD__)       // The port used will be LCD_DATA_PORT.
   int    reserved: 8;
  #endif
} LCD_PIN_MAP;
 
#if defined(__PCB__)
   // these definitions only need to be modified for baseline PICs.
   // all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions.
/*                                    EN, RS,   RW,   UNUSED,  DATA  */
 const LCD_PIN_MAP LCD_OUTPUT_MAP =  {0,  0,    0,    0,       0};
 const LCD_PIN_MAP LCD_INPUT_MAP =   {0,  0,    0,    0,       0xF};
#endif
 
#ifndef LCD_ENABLE_PIN
   #define lcd_output_enable(x) lcdlat.enable=x
   #define lcd_enable_tris()   lcdtris.enable=0
#else
   #define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)
   #define lcd_enable_tris()  output_drive(LCD_ENABLE_PIN)
#endif
 
#ifndef LCD_RS_PIN
   #define lcd_output_rs(x) lcdlat.rs=x
   #define lcd_rs_tris()   lcdtris.rs=0
#else
   #define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
   #define lcd_rs_tris()  output_drive(LCD_RS_PIN)
#endif
 
#ifndef LCD_RW_PIN
   #define lcd_output_rw(x) lcdlat.rw=x
   #define lcd_rw_tris()   lcdtris.rw=0
#else
   #define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
   #define lcd_rw_tris()  output_drive(LCD_RW_PIN)
#endif
 
#ifndef LCD_DATA_PORT
   #if defined(__PCB__)
      #define LCD_DATA_PORT      0x06     //portb
      #define set_tris_lcd(x)   set_tris_b(x)
   #elif defined(__PCM__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")     //portd
   #elif defined(__PCH__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")    //portd
   #elif defined(__PCD__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")    //portd
   #endif   
#endif
 
#if defined(__PCB__)
   LCD_PIN_MAP lcd, lcdlat;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
#elif defined(__PCM__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
   #byte lcdtris = LCD_DATA_PORT+0x80
#elif defined(__PCH__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT+9
   #byte lcdtris = LCD_DATA_PORT+0x12
#elif defined(__PCD__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #word lcd = LCD_DATA_PORT
   #word lcdlat = LCD_DATA_PORT+2
   #word lcdtris = LCD_DATA_PORT-0x02
#endif
 
#ifndef LCD_TYPE
   #define LCD_TYPE 2           // 0=5x7, 1=5x10, 2=2 lines
#endif
 
#ifndef LCD_LINE_TWO
   #define LCD_LINE_TWO 0x40    // LCD RAM address for the second line
#endif
 
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
                             // These bytes need to be sent to the LCD
                             // to start it up.
 
 
BYTE lcd_read_nibble(void);
 
BYTE lcd_read_byte(void)
{
   BYTE low,high;
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_float(LCD_DATA0);
   output_float(LCD_DATA1);
   output_float(LCD_DATA2);
   output_float(LCD_DATA3);
  #else
   lcdtris.data = 0xF;
  #endif
 #endif
        
   lcd_output_rw(1);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_cycles(1);
   high = lcd_read_nibble();
      
   lcd_output_enable(0);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(1);
   low = lcd_read_nibble();
      
   lcd_output_enable(0);
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_drive(LCD_DATA0);
   output_drive(LCD_DATA1);
   output_drive(LCD_DATA2);
   output_drive(LCD_DATA3);
  #else
   lcdtris.data = 0x0;
  #endif
 #endif
 
   return( (high<<4) | low);
}
 
BYTE lcd_read_nibble(void)
{
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   BYTE n = 0x00;
 
   /* Read the data port */
   n |= input(LCD_DATA0);
   n |= input(LCD_DATA1) << 1;
   n |= input(LCD_DATA2) << 2;
   n |= input(LCD_DATA3) << 3;
   
   return(n);
  #else
   return(lcd.data);
  #endif
}
 
void lcd_send_nibble(BYTE n)
{
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   /* Write to the data port */
   output_bit(LCD_DATA0, BIT_TEST(n, 0));
   output_bit(LCD_DATA1, BIT_TEST(n, 1));
   output_bit(LCD_DATA2, BIT_TEST(n, 2));
   output_bit(LCD_DATA3, BIT_TEST(n, 3));
  #else      
   lcdlat.data = n;
  #endif
      
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(2);
   lcd_output_enable(0);
}
 
void lcd_send_byte(BYTE address, BYTE n)
{
   lcd_output_rs(0);
   while ( bit_test(lcd_read_byte(),7) ) ;
   lcd_output_rs(address);
   delay_cycles(1);
   lcd_output_rw(0);
   delay_cycles(1);
   lcd_output_enable(0);
   lcd_send_nibble(n >> 4);
   lcd_send_nibble(n & 0xf);
}
 
void lcd_init(void) 
{
   BYTE i;
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_drive(LCD_DATA0);
   output_drive(LCD_DATA1);
   output_drive(LCD_DATA2);
   output_drive(LCD_DATA3);
  #else
   lcdtris.data = 0x0;
  #endif
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();
 #endif
 
   lcd_output_rs(0);
   lcd_output_rw(0);
   lcd_output_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[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 '\n'   : lcd_gotoxy(1,2);        break;
     
      case '\b'   : 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);
   while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
   lcd_output_rs(1);
   value = lcd_read_byte();
   lcd_output_rs(0);
   
   return(value);
}

Libreria Comentada y traducida

Código: CSS

///////////////////////////////////////////////////////////////////////////////
////                             LCD.C                                     ////
////                 CONTROLADOR  PARA  MODULO LCD COMUN                   ////
////                                                                       ////
////  lcd_init()   Debe ser llamada antes que cualquier otra función.      ////
////                                                                       ////
////  lcd_putc(c)  Mostrara c en la próxima posición del LCD.              ////
////                     Lo siguiente tiene especial significado:          ////
////                      \f  Limpiar display                              ////
////                      \n  Ir al inicio de la segunda línea             ////
////                      \b  Retroceder una posición                      ////
////                                                                       ////
////  lcd_gotoxy(x,y) situa cursor en LCD (arriba izquierda es 1,1)        ////
////                                                                       ////
////  lcd_getc(x,y)   Retorna caracter en posición x,y en el LCD           ////
////                                                                       ////
////  CONFIGURACION                                                        ////
////  El LCD puede ser configurado en uno o dos modos:                     ////
////  a.) acceso al puerto; requiere la entrada de 7 bits conectados       ////
////  al puerto y los bit de datos(D4:D7 del LCD) conectados               ////
////  secuencialmente.                                                     ////
////  b.) acceso al pin; no requiere conesion secuancial y los 7 bit       ////
////  pueden estar conectados usando cualquier puerto.                     ////
////                                                                       ////
////  To use port access, #define LCD_DATA_PORT to the SFR location of     ////
////  of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP    ////
////  of this file to configure the pin order.  If you are using a         ////
////  baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must  ////
////  be defined.                                                          ////
////                                                                       ////
////  Ejemplo de puerto de acceso:                                         ////
////     #define LCD_DATA_PORT getenv("SFR:PORTD")                         ////
////                                                                       ////
////  Para usar pin de acceso, los siguientes pines deben ser definidos:   ////
////     LCD_ENABLE_PIN                                                    ////
////     LCD_RS_PIN                                                        ////
////     LCD_RW_PIN                                                        ////
////     LCD_DATA0                                                         ////
////     LCD_DATA1                                                         ////
////     LCD_DATA2                                                         ////
////     LCD_DATA3                                                         ////
////     LCD_DATA4                                                         ////
////                                                                       ////
////  Ejemplo de pin de acceso:                                            ////
////     #define LCD_ENABLE_PIN  PIN_E0                                    ////
////     #define LCD_RS_PIN      PIN_E1                                    ////
////     #define LCD_RW_PIN      PIN_E2                                    ////
////     #define LCD_DATA0       PIN_D4                                    ////
////     #define LCD_DATA1       PIN_D5                                    ////
////     #define LCD_DATA2       PIN_D6                                    ////
////     #define LCD_DATA3       PIN_D7                                    ////
////                                                                       ////
///////////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2009 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.                               ////
///////////////////////////////////////////////////////////////////////////
 
 
// define una esctructura cuyo contenido son los pines de control E,RS,RW
//
// B0
// B1
// B2
// B3
// B4
// B5
// B6
// B7
//
 
/*
typedef struct  
{                            // La estructuta esta superpuesta 
   BOOLEAN enable;           // sobre las entradas del puerto 
   BOOLEAN rs;               // para acceder a los pines del LCD.  
   BOOLEAN rw;               // Los bits estan localizados en 
   BOOLEAN unused;           // orden de abajo a arriba.  ENABLE sera el pin
   int     data : 4;         // LSB (bit menos significativo) del puerto.
  #if defined(__PCD__)       // El puerto usado sera LCD_DATA_PORT.
   int    reserved: 8;
  #endif
} LCD_PIN_MAP;
*/
 
typedef struct               // Definición de estructura
{                             
   BOOLEAN enable;           // 
   BOOLEAN rs;               //  
   BOOLEAN rw;               // 
   BOOLEAN unused;           // 
   int     data : 4;         // 
  #if defined(__PCD__)       // si el compilador es de pic24 y DSpic
   int    reserved: 8;       // reserva ram para el uso del compilador
  #endif                     // 
} LCD_PIN_MAP;               // variable 
 
 
 
 
#if defined(__PCB__)         //evalua el pre-procesador si es pic 10 (12 bits)
   // Estas definiciones solo necesitan ser modificadas en referencia a los PIC de referencia basica.
   // Todos los demas PIC usan "LCD_PIN_MAP" o individual "LCD_xxx" definiciones de pines.
 
/*                                    EN, RS,   RW,   UNUSED,  DATA  */
 const LCD_PIN_MAP LCD_OUTPUT_MAP =  {0,  0,    0,    0,       0};
 const LCD_PIN_MAP LCD_INPUT_MAP =   {0,  0,    0,    0,       0xF};
#endif
 
#ifndef LCD_ENABLE_PIN                                              //si no esta definido el pin enable
   #define lcd_output_enable(x) lcdlat.enable=x                     //lo define en x
   #define lcd_enable_tris()   lcdtris.enable=0                     //lo define como salida  
#else
   #define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)       //
   #define lcd_enable_tris()  output_drive(LCD_ENABLE_PIN)          //
#endif
 
#ifndef LCD_RS_PIN
   #define lcd_output_rs(x) lcdlat.rs=x
   #define lcd_rs_tris()   lcdtris.rs=0
#else
   #define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
   #define lcd_rs_tris()  output_drive(LCD_RS_PIN)
#endif
 
#ifndef LCD_RW_PIN
   #define lcd_output_rw(x) lcdlat.rw=x
   #define lcd_rw_tris()   lcdtris.rw=0
#else
   #define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
   #define lcd_rw_tris()  output_drive(LCD_RW_PIN)
#endif
 
#ifndef LCD_DATA_PORT
   #if defined(__PCB__)
      #define LCD_DATA_PORT      0x06     //portb
      #define set_tris_lcd(x)   set_tris_b(x)
   #elif defined(__PCM__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")     //portd
   #elif defined(__PCH__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")    //portd
   #elif defined(__PCD__)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")    //portd
   #endif   
#endif
 
#if defined(__PCB__)
   LCD_PIN_MAP lcd, lcdlat;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
#elif defined(__PCM__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
   #byte lcdtris = LCD_DATA_PORT+0x80
#elif defined(__PCH__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT+9
   #byte lcdtris = LCD_DATA_PORT+0x12
#elif defined(__PCD__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #word lcd = LCD_DATA_PORT
   #word lcdlat = LCD_DATA_PORT+2
   #word lcdtris = LCD_DATA_PORT-0x02
#endif
 
#ifndef LCD_TYPE
   #define LCD_TYPE 2           // 0=5x7, 1=5x10, 2=2 lineas
#endif
 
#ifndef LCD_LINE_TWO
   #define LCD_LINE_TWO 0x40    // direcion RAM del LCD para la segunda linea
#endif
/*
BYTE const LCD_INIT_STRING[4] = 
{
 0x20 | (lcd_type << 2),        // modo 4-bits, 2lineas, 5x8 puntos 
 0xc,                           // Display on
 1,                             // Limpiar displays
 6                              // incrementa cursor
};
                             // estos bytes son necesarios enviarlos al LCD
                             // para iniciar el arranque.
*/
 
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
                             // estos bytes son necesarios enviarlos al LCD
                             // para iniciar el arranque.
 
BYTE lcd_read_nibble(void);  //lee 4 bits
 
BYTE lcd_read_byte(void)     //lee 8 bits
{
   BYTE low,high;
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_float(LCD_DATA0);
   output_float(LCD_DATA1);
   output_float(LCD_DATA2);
   output_float(LCD_DATA3);
  #else
   lcdtris.data = 0xF;
  #endif
 #endif
        
   lcd_output_rw(1);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_cycles(1);
   high = lcd_read_nibble();
      
   lcd_output_enable(0);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(1);
   low = lcd_read_nibble();
      
   lcd_output_enable(0);
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_drive(LCD_DATA0);
   output_drive(LCD_DATA1);
   output_drive(LCD_DATA2);
   output_drive(LCD_DATA3);
  #else
   lcdtris.data = 0x0;
  #endif
 #endif
 
   return( (high<<4) | low);
}
 
BYTE lcd_read_nibble(void)
{
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   BYTE n = 0x00;
 
   /* Read the data port */
   n |= input(LCD_DATA0);
   n |= input(LCD_DATA1) << 1;
   n |= input(LCD_DATA2) << 2;
   n |= input(LCD_DATA3) << 3;
   
   return(n);
  #else
   return(lcd.data);
  #endif
}
 
void lcd_send_nibble(BYTE n)
{
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   /* Write to the data port */
   output_bit(LCD_DATA0, BIT_TEST(n, 0));
   output_bit(LCD_DATA1, BIT_TEST(n, 1));
   output_bit(LCD_DATA2, BIT_TEST(n, 2));
   output_bit(LCD_DATA3, BIT_TEST(n, 3));
  #else      
   lcdlat.data = n;
  #endif
      
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(2);
   lcd_output_enable(0);
}
 
void lcd_send_byte(BYTE address, BYTE n)
{
   lcd_output_rs(0);
   while ( bit_test(lcd_read_byte(),7) ) ;
   lcd_output_rs(address);
   delay_cycles(1);
   lcd_output_rw(0);
   delay_cycles(1);
   lcd_output_enable(0);
   lcd_send_nibble(n >> 4);
   lcd_send_nibble(n & 0xf);
}
 
void lcd_init(void) 
{
   BYTE i;
 
 #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
 #else
  #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
   output_drive(LCD_DATA0);
   output_drive(LCD_DATA1);
   output_drive(LCD_DATA2);
   output_drive(LCD_DATA3);
  #else
   lcdtris.data = 0x0;
  #endif
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();
 #endif
 
   lcd_output_rs(0);
   lcd_output_rw(0);
   lcd_output_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[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 '\n'   : lcd_gotoxy(1,2);        break;
     
      case '\b'   : 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);
   while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
   lcd_output_rs(1);
   value = lcd_read_byte();
   lcd_output_rs(0);
   
   return(value);
}

pajaro · « **Respuesta #2 en:** 21 de Agosto de 2009, 13:40:19 »

Código: CSS

////////////////////////////////////////////////////////////////////////////
////                             LCD420.C                               ////
////            Driver for common 4x20 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                             ////
////                      \n  Go to start of second line                ////
////                      \b  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          ////
////                                                                    ////
////////////////////////////////////////////////////////////////////////////
////        (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.                                ////
////////////////////////////////////////////////////////////////////////////
 
// As defined in the following structure the pin connection is as follows:
//     B0  enable
//     B1  rs
//     B2  rw
//     B4  D4
//     B5  D5
//     B6  D6
//     B7  D7
//
//   LCD pins D0-D3 are not used and PIC B3 is not used.
 
struct lcd_pin_map {                 // This structure is overlayed
           BOOLEAN enable;           // on to an I/O port to gain
           BOOLEAN rs;               // access to the LCD pins.
           BOOLEAN rw;               // The bits are allocated from
           BOOLEAN unused;           // low order up.  ENABLE will
           int     data : 4;         // be pin B0.
        } lcd;
//seleccion del puerto : A(5), B(6), C(7), D(8), E(9)
#byte lcd = 6                        // This puts the entire structure
                                     // on to port B (at address 6)
 
#define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
 
 
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
                             // 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.
 
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 = {0,0,0,0,15}; // For read mode data pins are in
 
 
BYTE lcdline;
 
BYTE lcd_read_byte() {
      BYTE low,high;
 
      set_tris_b(LCD_READ);
      lcd.rw = 1;
      delay_cycles(1);
      lcd.enable = 1;
      delay_cycles(1);
      high = lcd.data;
      lcd.enable = 0;
      delay_cycles(1);
      lcd.enable = 1;
      delay_us(1);
      low = lcd.data;
      lcd.enable = 0;
      set_tris_b(LCD_WRITE);
      return( (high<<4) | low);
}
 
 
void lcd_send_nibble( BYTE n ) {
      lcd.data = n;
      delay_cycles(1);
      lcd.enable = 1;
      delay_us(2);
      lcd.enable = 0;
}
 
 
void lcd_send_byte( BYTE address, BYTE n ) {
 
      lcd.rs = 0;
      while ( bit_test(lcd_read_byte(),7) ) ;
      lcd.rs = address;
      delay_cycles(1);
      lcd.rw = 0;
      delay_cycles(1);
      lcd.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
}

pajaro · « **Respuesta #3 en:** 21 de Agosto de 2009, 13:40:39 »

flex.c

pajaro · « **Respuesta #4 en:** 21 de Agosto de 2009, 13:41:14 »

Controlador Flexible LCD 16x1

Código: CSS

// Flex_lcd_16x1.c
 
// These are randomly assigned pins, used to test
// that the driver can work with any arrangement
// of i/o pins. 
#define LCD_DB4   PIN_D4
#define LCD_DB5   PIN_B1
#define LCD_DB6   PIN_C0
#define LCD_DB7   PIN_E0
 
#define LCD_RS    PIN_E2
#define LCD_RW    PIN_B2
#define LCD_E     PIN_D6
 
/*
#define LCD_DB4   PIN_D4
#define LCD_DB5   PIN_D5
#define LCD_DB6   PIN_D6
#define LCD_DB7   PIN_D7
 
#define LCD_RS    PIN_E0
#define LCD_RW    PIN_E1
#define LCD_E     PIN_E2
*/
 
// If you want to use a 6-pin interface for your LCD, then
// connect the R/W pin on the LCD to ground and comment
// out the following line.  A 6-pin interface to the LCD
// is used if only have a few free i/o pins available on
// your PIC, and you want to use the smallest possible
// number of pins for the LCD.
#define USE_LCD_RW   1       
 
//========================================
// Use "2 lines" as the lcd type for the 16x1 LCD.
// The LCD is the same as an 8x2 LCD, but with the
// bottom line appended on the right side of the first line.
#define LCD_TYPE  2         // 0=5x7, 1=5x10, 2=2 lines
#define LCD_2ND_HALF_ADDRESS  0x40
 
#define LCD_WIDTH  16
#define LCD_HALF_WIDTH  (LCD_WIDTH/2)
 
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
 };
 
int8 lcd_xcoord;
                             
 
//-------------------------------------
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 & 8));   
 
 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_us(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);
delay_us(1); 
   
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);
 
// Some LCDs require 15 ms minimum delay after
// power-up.  Others require 30 ms.  I'm going
// to set it to 35 ms, so it should work with
// all of them.
delay_ms(35);     
 
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
   }
 
lcd_xcoord = 1;
}
 
//----------------------------
// The x-coordinate can be 1 to 16.
// The y coordinate is ignored. 
// This x,y interface is kept in order to be
// consistent with other CCS LCD drivers.
void lcd_gotoxy(int8 x, int8 y)
{
int8 address;
 
// Update the global x-coordinate variable with the
// current x coordinate.
lcd_xcoord = x;
 
// Convert the x-coordinate from CCS format (1-16) to
// the 0-15 format used by the LCD hardware.
address = x - 1; 
 
// If the x-coordinate is within the 2nd half of the
// LCD line, the address must be adjusted because
// of the special architecture of the 8x2 LCD.
if(address >= LCD_HALF_WIDTH) 
  {   
   address += (LCD_2ND_HALF_ADDRESS - LCD_HALF_WIDTH);
  }
 
lcd_send_byte(0, 0x80 | address);
}
 
 
//-----------------------------
void lcd_putc(char c)
{
 switch(c)
   {
    case '\f':
      lcd_send_byte(0,1);
      delay_ms(2);
      lcd_xcoord = 1;
      break;
   
    case '\n':
       lcd_gotoxy(1,1);  //  Goto start of line 1
       break;
   
    case '\b':
       lcd_send_byte(0, 0x10);
       lcd_xcoord--;
       if(lcd_xcoord == LCD_HALF_WIDTH)
          lcd_gotoxy(LCD_HALF_WIDTH, 1);
       break;
   
    default:
       lcd_send_byte(1, c);
       lcd_xcoord++;
       if(lcd_xcoord == (LCD_HALF_WIDTH +1))
          lcd_gotoxy(LCD_HALF_WIDTH +1, 1);
       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

pajaro · « **Respuesta #5 en:** 21 de Agosto de 2009, 13:41:44 »

Controlador Flexible 16x2

Código: CSS

// 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 & 8));   
 
 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 '\n':
       lcd_gotoxy(1,2);
       break;
   
    case '\b':
       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

pajaro · « **Respuesta #6 en:** 21 de Agosto de 2009, 13:42:00 »

lcd03

pajaro · « **Respuesta #7 en:** 21 de Agosto de 2009, 13:44:28 »

Controlador Flexible LCD 20x4

Código: CSS

// Flex_LCD420.c
 
// These pins are for my Microchip PicDem2-Plus board,
// which I used to test this driver.
// An external 20x4 LCD is connected to these pins.
// Change these pins to match your own board's connections.
 
#define LCD_DB4   PIN_D4
#define LCD_DB5   PIN_D5
#define LCD_DB6   PIN_D6
#define LCD_DB7   PIN_D7
 
#define LCD_RS    PIN_E0
#define LCD_RW    PIN_E1
#define LCD_E     PIN_E2
 
/*
// To prove that the driver can be used with random
// pins, I also tested it with these pins:
#define LCD_DB4   PIN_D4
#define LCD_DB5   PIN_B1
#define LCD_DB6   PIN_C5
#define LCD_DB7   PIN_B5
 
#define LCD_RS    PIN_E2
#define LCD_RW    PIN_B2
#define LCD_E     PIN_D6
*/
 
// If you want only a 6-pin interface to your LCD, then
// connect the R/W pin on the LCD to ground, and comment
// out the following line.  Doing so will save one PIC
// pin, but at the cost of losing the ability to read from
// the LCD.  It also makes the write time a little longer
// because a static delay must be used, instead of polling
// the LCD's busy bit.  Normally a 6-pin interface is only
// used if you are running out of PIC pins, and you need
// to use as few as possible for the LCD.
#define USE_RW_PIN   1     
 
 
// These are the line addresses for most 4x20 LCDs.
#define LCD_LINE_1_ADDRESS 0x00
#define LCD_LINE_2_ADDRESS 0x40
#define LCD_LINE_3_ADDRESS 0x14
#define LCD_LINE_4_ADDRESS 0x54
 
// These are the line addresses for LCD's which use
// the Hitachi HD66712U controller chip.
/*
#define LCD_LINE_1_ADDRESS 0x00
#define LCD_LINE_2_ADDRESS 0x20
#define LCD_LINE_3_ADDRESS 0x40
#define LCD_LINE_4_ADDRESS 0x60
*/
 
 
//========================================
 
#define lcd_type 2   // 0=5x7, 1=5x10, 2=2 lines(or more)
 
int8 lcd_line;
 
int8 const LCD_INIT_STRING[4] =
{
 0x20 | (lcd_type << 2),  // Set mode: 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 & 8));   
 
 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_RW_PIN
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_us(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);
delay_us(1);
   
return(retval);   
}   
#endif
 
//---------------------------------------
// Read a byte from the LCD and return it.
 
#ifdef USE_RW_PIN
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_RW_PIN
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_RW_PIN
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;
 
lcd_line = 1;
 
output_low(LCD_RS);
 
#ifdef USE_RW_PIN
output_low(LCD_RW);
#endif
 
output_low(LCD_E);
 
// Some LCDs require 15 ms minimum delay after
// power-up.  Others require 30 ms.  I'm going
// to set it to 35 ms, so it should work with
// all of them.
delay_ms(35);         
 
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 50 us, so in
    // that case, lets just do a 5 ms delay
    // after all four of them.
    #ifndef USE_RW_PIN
    delay_ms(5);
    #endif
   }
 
}
 
//----------------------------
 
void lcd_gotoxy(int8 x, int8 y)
{
int8 address;
 
 
switch(y)
  {
   case 1:
     address = LCD_LINE_1_ADDRESS;
     break;
 
   case 2:
     address = LCD_LINE_2_ADDRESS;
     break;
 
   case 3:
     address = LCD_LINE_3_ADDRESS;
     break;
 
   case 4:
     address = LCD_LINE_4_ADDRESS;
     break;
 
   default:
     address = LCD_LINE_1_ADDRESS;
     break;
     
  }
 
address += x-1;
lcd_send_byte(0, 0x80 | address);
}
 
//-----------------------------
void lcd_putc(char c)
{
 switch(c)
   {
    case '\f':
      lcd_send_byte(0,1);
      lcd_line = 1;
      delay_ms(2);
      break;
   
    case '\n':
       lcd_gotoxy(1, ++lcd_line);
       break;
   
    case '\b':
       lcd_send_byte(0,0x10);
       break;
   
    default:
       lcd_send_byte(1,c);
       break;
   }
}
 
//------------------------------
#ifdef USE_RW_PIN
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

pajaro · « **Respuesta #8 en:** 21 de Agosto de 2009, 13:58:42 »

LCD_05

drivers personalizados

Código: CSS

http://www.todopic.com.ar/foros/index.php?topic=14552.20
 
 
 
/******************************************************/
/*
/* Manejo de un Display de Cristal Liquido LCD 16X4   */
/* de 16 caracteres por 4 lineas, el LCD se encuentra */
/* conectado en el Puerto D del microcontrolador, con */
/* una interface de 4 lineas:                         */
/*
/* LCD PIC
/* ------------------------------------
/* D4  (11) --> RD0
/* D5  (12) --> RD1
/* D6  (13) --> RD2
/* D7  (14) --> RD3
/*
/* RS  (4) --> RD4
/* RW  (5) --> RD5
/* E   (6) --> RD6
/*
/******************************************************/
/* Conexiones del LCD al Microcontrolador */
//#include <delays.h>
 
#define RS RD4
#define RW RD5
#define E  RD6
 
/* Configuracion del Display y cursor */
 
#define DON              0b00001111  /* Display encendido   */
#define DOFF             0b00001011  /* Display apagado     */
#define CURSOR_HOME      0b00000010  /* Cursor encendido    */
#define CURSOR_ON        0b00001111  /* Cursor encendido    */
#define CURSOR_OFF       0b00001101  /* Cursor apagado      */
#define BLINK_ON         0b00001111  /* Cursor con parpadeo */
#define BLINK_OFF        0b00001110  /* Cursor sin parpadeo */
#define CLEAR            0b00000001  /* Display encendido   */
 
 
/* Modo de entrada */
 
#define INCREMENT 0b00000110  /* Incrementa la posicion del cursor */
#define DECREMENT 0b00000100  /* Decrementa la posicion del cursor */
 
/* Configuracion de los desplazamientos del cursor y del Display*/
 
#define SHIFT_CUR_LEFT   0b00010011  /* Corrimiento del cursor a la izquierda  */
#define SHIFT_CUR_RIGHT  0b00010111  /* Corrimiento del cursor a la derecha    */
#define SHIFT_DISP_LEFT  0b00011011  /* Corrimiento del display a la izquierda */
#define SHIFT_DISP_RIGHT 0b00011111  /* Corrimiento del display a la derecha   */
 
/* Funciones de inicializacion */
 
#define NIBLE            0b00000010  /* interface a 4 bits */
#define FOUR_BIT         0b00101111  /* Interface a 4-bit  */
#define EIGHT_BIT        0b00111111  /* Interface a 8-bit  */
#define LINE_5X7         0b00110011  /* Una linea, caracter 5x7 */
 
#define LINE_5X10 0b00110111  /* Una linea, caracter 5x10 */
#define LINES_5X7 0b00111011  /* Dos lineas. character 5x7 */
 
 
 
/* Lineas de trabajo */
 
 
 
#define DDRAM_LINEA_1 0b10000000 /* Linea 1 */
#define DDRAM_LINEA_2 0b11000000 /* Linea 2 */
#define DDRAM_LINEA_3 0b10010000 /* Linea 3 */
#define DDRAM_LINEA_4 0b11010000 /* Linea 4 */
 
/* Configuracion del puerto */
 
#define Config_Puerto     0b00000000          // RC<0:6> como salidas 
#define Mascara           0b00001111          // Parte baja del Byte  
 
/* Prototipos de funciones */
 
void Inicializa_LCD(void);                // Inicializa LCD 
void Comando_LCD(char);                   // Indica al LCD un comando 
void Dato_LCD(char);                      // Indica al LCD un caracter 
 
/* Inicializacion del LCD segun fabricante */
 
void Inicializa_LCD(void)
{
 
  int i;
  PORTD = 0;                     // Puerto D a utilizar E = RS = RW = 0 
  TRISD = Config_Puerto;
 
  Delay10TCYx(110);           /* Retardo mayor a 100 useg. */
  PORTD = NIBLE;              /* Interface de 4 bits RC<0:3> */
  PORTDbits.RS = 0;           /* RS = 0 */
  PORTDbits.RW = 0;           /* RW = 0 */
  PORTDbits.E = 1;            /* E = 1 */
  Delay1KTCYx(5);             /* Retardo de 5 mseg. */
  PORTDbits.E = 0;            /* E = 0 */
  Delay1KTCYx(15);            /* Retardo de 15 mseg. */
 
/* Funcion set,  DL = 0, N = 1, F = 0 */
/* Dos lineas, caracter de 5X7 e interface a 4 bits */
  Comando_LCD(LINES_5X7 & FOUR_BIT);
 
/* Display ON, D = 1, C = 1, B = 1 */
/* Display encendido, cursor encendido con parpadeo */
 
  Comando_LCD(DON & CURSOR_ON & BLINK_ON);
 
/* limpia el display */
  Comando_LCD(CLEAR);
 
 
/* Entry Mode Set */
/* Incremento del cursor */
 
  Comando_LCD(INCREMENT);
 
}
 
 
/* Indica al LCD comandos */
void Comando_LCD(char dato)
{
  char temp;                   /* variable auxiliar */
  Delay1KTCYx(10);             /* Retardo de 10 mseg. */
  temp = dato;                 /* Respaldo del dato original */
  dato = dato >> 4;            /* Corrimiento del nible alto */
  PORTD = dato & Mascara;      /* Manda parte alta del nible */
  PORTDbits.RS = 0;            /* Indica que es un comando */
  PORTDbits.RW = 0;            /* RW = 0 */
  PORTDbits.E = 1;             /* Pone a E = 1 */
  Delay1KTCYx(5);              /* Retardo de 5 mseg. */
 
  PORTDbits.E = 0;             /* Pone a E = 0 */
  PORTD = temp & Mascara;      /* Parte baja del Byte */
  PORTDbits.RS = 0;            /* Indica que es un comando */
  PORTDbits.RW = 0;            /* RW = 0 */
  PORTDbits.E = 1;             /* Pone a E = 1 */
  Delay1KTCYx(5);              /* Retardo de 5 mseg. */
  PORTDbits.E = 0;             /* Pone a E = 0 */
 
}
 
/* Manda datos al LCD */
 
void Dato_LCD(char dato)
{
  char temp;                   /* variable auxiliar */
  Delay1KTCYx(10);             /* Retardo de 10 mseg. */
  temp = dato;                 /* Respaldo del dato original */
  dato = dato >> 4;            /* Corrimiento del nible alto */
  PORTD = dato & Mascara;      /* Manda parte alta del nible */
  PORTDbits.RS = 1;            /* Indica que es un caracter */
  PORTDbits.RW = 0;            /* RW = 0 */
  PORTDbits.E = 1;             /* Pone a E = 1 */
  Delay1KTCYx(5);              /* Retardo de 5 mseg. */
  PORTDbits.E = 0;             /* Pone a E = 0 */
  PORTD = temp & Mascara;      /* Parte baja del Byte */
  PORTDbits.RS = 1;            /* RS = 0 */
  PORTDbits.RW = 0;            /* RW = 0 */
  PORTDbits.E = 1;             /* Pone a E = 1 */
  Delay1KTCYx(5);              /* Retardo de 5 mseg. */
  PORTDbits.E = 0;             /* Pone a E = 0 */
}

otro

Código: CSS

http://www.todopic.com.ar/foros/index.php?topic=24085.20
 
 
 
/*
 Yo estoy usando el compilador CCS 4.08 y el pic16f874a no sé si es un bugs o es que me enviaron para callarme,
 un código cualquiera de internet por favor ayúdenme le agradesco por su comprensión.
Pd aquí le envió el código completo que me entrego la empresa para el LCD:*/
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                    LCD.H                                                     //
//                                                VERSION   2.1                                                 //
//                                                 JULIO 2009                                                   //
//                                                                                                              //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#nolist
 
                                   // DEFINICION DE CONSTANTES PARA USO EN FUNCIONES
#define HOME             0x02      // PARA PONER CURSOR EN LA POSICION 0 DEL DISPLAY. USAR CON WRITE_LCD_COM
#define INCREASE         0x02      // INCREMENTA CURSOR. USAR CON LCD.ID
#define DECREASE         0x00      // DECREMENTA CURSOS. USAR CON LCD.ID
#define SHIFT_ON         0x01      // SHIFT DISPLAY. USAR CON LCD.SHIFT
#define SHIFT_OFF        0x00      // NO SHIFT DISPLAY. USAR CON LCD.SHIFT
#define LCD_ON           0x04      // ACTIVA LCD. USAR CON LCD.MODE
#define LCD_OFF          0x00      // DESACTIVA LCD. USAR CON LCD.MODE
#define CURSOR_ON        0x02      // ACTIVA CURSOR. USAR CON LCD.CURSOR
#define CURSOR_OFF       0x00      // DESACTIVA CURSOR. USAR CON LCD.CURSOR
#define BLINK_ON         0x01      // ACTIVA PARPADEO DEL CURSOR. USAR CON LCD.BLINK   
#define BLINK_OFF        0x00      // DESACTIVA PARPADEO DEL CURSOR. USAR CON LCD.BLINK   
#define BUS_8            0x10      // DEFINE BUS DE 8 BITS. USAR CON LCD.INTERFASE
#define BUS_4            0x00      // DEFINE BUS DE 4 BITS. USAR CON LCD.INTERFASE
#define CLEAR            0x01      // LIMPIA DISPLAY. USAR CON FUNCION WRITE_LCD_DATA()
#define NOCLEAR          0x00      // NO LIMPIA DISPLAY. USAR CON FUNCION WRITE_LCD_DATA()
#define LINE1            0x00      // PRIMERA DIRECCION DE LINEA 1.
#define LINE2            0x40      // PRIMERA DIRECCION DE LINEA 2.
#define LINE3            0x14      // PRIMERA DIRECCION DE LINEA 3.
#define LINE4            0x54      // PRIMERA DIRECCION DE LINEA 4.
#define LARGO            16        // Editar esta línea para indicar la cantidad de caracteres por línea del display
#define LINEAS           2         // Editar este línea para indicar la cantidad de líneas que dispone el display
#define NULL             0x00
 
#list
 
struct
{
   char TEXT[LARGO+1];             // define texto para escribir en lcd   
   int ID;                         // define si el cursor de incrementará o decrementará
   int SHIFT;                      // define el shift del cursor
   int MODE;                       // define si el display está ON ú OFF
   int CURSOR;                     // define si el cursor estará visible
   int BLINK;                      // define si el cursor parpadeará
   int INTERFASE;                  // define interfase de 4/8 bits
} lcd;
 
// CONFIGURAR AQUI LOS PUERTO QUE SE USARAN PARA BUS DE DATOS Y DE CONTROL
 
#byte DataBus = PORTD              // DEFINE BUS DE DATOS
#byte Tris_DataBus = TRISD         // DEFINE TRIS DE BUS DE DATOS
#byte ControlBus = PORTE           // DEFINE BUS DE CONTROL
#byte Tris_ControlBus = TRISE      // DEFINE TRIS DEL BUS DE CONTROL
 
 
// GENERA PULSOS DE ESCRITURA PARA COMANDOS DEL DISPLAY Y SACA DATO
 
void WriteLcdComData(int x)
{
   Tris_ControlBus = 0xF8 & Tris_ControlBus;
   Tris_DatalBus = 0x00;
   DataBus = ControlBus = 0x00;
   ControlBus = 3;
   ControlBus = 0;
   ControlBus = 4;
   DataBus = x;
   ControlBus = 0;
   ControlBus = 3;
   delay_us(50);
}
 
// LIMPIA DISPLAY
void ClearLcd(void)
{
   WriteLcdComData(CLEAR);               // display clear
   delay_ms(2);
}
 
// INICIALIZA EL EL DISPLAY
 void IniLcd(void)
{
   delay_ms(20);
   WriteLcdComData(0x30);
   delay_ms(5);   
   WriteLcdComData(0x30);
   delay_us(150);
   WriteLcdComData(0x30);   
}
 
// CONFIGURA EL DISPLAY. LOS DATOS PARA LA CONFIGURACION DEBEN SER PUERTOS ANTES DE LLAMAR
// A ESTA FUNCION. LOS DATOS SON PARTE DE LA ESTRUCTURA LCD.
void SetupLcd(void)
{
   WriteLcdComData(0x04 | lcd.ID | lcd.SHIFT);                     //ENTRY MODE SET
   WriteLcdComData(0x08 | lcd.MODE | lcd.CURSOR | lcd.BLINK);      // DISPLAY ON OFF
   WriteLcdComData(0x28 | lcd.INTERFASE);                          // SET FUNCTION
}
 
// ESCRIBE DATOS EN EL DISPLAY. X REPRSENTA DESDE QUE DIRECCIÓN DEL DISPLAY SE DESEAN ESCRIBIR LOS DATOS
// E Y INDICA SE SE LIMPIARÁ EL DISPLAY ANTES DE ESCRIBIR
// SI C = CLEAN, EL DISPLAY ES LIMPIADO
// SI C = NOCLEAN, SOLO SE ESCRIBEN LOS DATOS DESDE LA POCISION ESPECIFICADA POR POS
// LOS DATOS A ESCRIBIR DEBE SER COPIADOS PREVIAMENTE EN EL ELEMENTO LCD.TEXT DE LA ESCTRUCTIRA LCD
void WriteLcd(int pos, int c)
{
   int *p;
   Tris_ControlBus = 0xF8 & Tris_ControlBus;
   Tris_DatalBus = 0x00;
   DataBus = ControlBus =0x00;
   if (c)
      {
         clear_lcd();
         delay_ms(2);
      }
   pos|= 0x80;
   WriteLcdComData(pos);
   p = lcd.TEXT;
   for (; *p!=NULL; p++)
   {   
      DataBus = 0xff;
      ControlBus = 2;
      ControlBus = 1;
      ControlBus = 5;
      DataBus = *p;
      ControlBus = 1;
      ControlBus = 2;
      delay_us(50);
   }
}
 
void PutcLcd(int ini, char data)
{
   if (ini != CURRENT)
      {
         ini|= 0x80;
         WriteLcdComData(ini);
      }
   Tris_ControlBus = 0xF8 & Tris_ControlBus;
   Tris_DatalBus = ControlBus = 0x00;
   DataBus = 0xff;
   ControlBus = 2;
   ControlBus = 1;
   ControlBus = 5;
   DataBus = data;
   ControlBus = 1;
   ControlBus = 2;
   delay_us(50);
}
 
void ClearLcdLine(int x)
{
   int y;
   for (y=0; y<=LARGO; y++)
      {
         lcd.TEXT[y] = ' ';
      }
   lcd.TEXT[++y] = NULL;
   switch (x)
      {
         case 1   :   WriteLcd(LINE1,NOCLEAR);
                        break;
         case 2   :   WriteLcd(LINE2,NOCLEAR);
                        break;
         case 3  :   WriteLcd(LINE3,NOCLEAR);
                        break;
         case 4  :   WriteLcd(LINE4,NOCLEAR);
                        break;
         default :   break;
      }
}

pajaro · « **Respuesta #9 en:** 21 de Agosto de 2009, 13:59:56 »

Código: CSS

/////////////////////////////////////////////////////////////////////////
////                             KS0108.c                            ////
////                                                                 ////
//// This file contains drivers for using a KS0108 LCD controller    ////
//// for a 64 by 64 pixel display. The driver treats the upper left  ////
//// pixel as (0,0).                                                 ////
////                                                                 ////
//// Use #define FAST_GLCD if the target chip has at least 512 bytes ////
//// of RAM to decrease the time it takes to update the display.     ////
//// KS0108_update() must then be called to update the display after ////
//// changing the display data.                                      ////
//// See HDM64GS12.c for controlling a display with two controllers  ////
/////////////////////////////////////////////////////////////////////////
////                                                                 ////
////  KS0108_init(int1 mode)                                         ////
////     * Must be called before any other function                  ////
////     * TRUE turns the display on, FALSE turns display off        ////
////                                                                 ////
////  KS0108_fill()                                                  ////
////     * Fills the entire LCD with the given data                  ////
////       - color can be ON or OFF                                  ////
////                                                                 ////
////  KS0108_pixel(int8 x, int8 y, int1 color)                       ////
////     * Set the color of the pixel at (x,y)                       ////
////     * TRUE turns the pixel on, FALSE turns the pixel off        ////
////                                                                 ////
////  KS0108_update()                                                ////
////     * Write the display data stored in RAM to the LCD           ////
////     * Only available if FAST_GLCD is defined                    ////
////                                                                 ////
////  int8 KS0108_status()                                           ////
////     * Read the status register                                  ////
////       7:    0 - Ready   1 - Busy                                ////
////       6:    0                                                   ////
////       5:    0 - On      1 - Off                                 ////
////       4:    0 - Normal  1 - Reset                               ////
////       3-0:  0                                                   ////
////                                                                 ////
////  KS0108_topRow(row)                                             ////
////     * Specify the row appearing at the top of the screen (0-63) ////
////                                                                 ////
////  KS0108_on()                                                    ////
////     * Turn the display on                                       ////
////                                                                 ////
////  KS0108_off()                                                   ////
////     * Turn the display off                                      ////
////                                                                 ////
////  KS0108_page(page)                                              ////
////     * Set the page number (0-7)                                 ////
////                                                                 ////
////  KS0108_column(column)                                          ////  
////     * Set the column address (0-63)                             ////
////                                                                 ////
////  KS0108_inst()                                                  ////
////     * Specify reads and writes are instructions                 ////
////                                                                 ////
////  KS0108_data()                                                  ////
////     * Specify reads and writes are data                         ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996, 2004 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.              ////
/////////////////////////////////////////////////////////////////////////
 
#ifndef KS0108
#define KS0108
 
#ifndef KS0108_CS
#define KS0108_CS             PIN_B0   // Chip select
#endif
#ifndef KS0108_DI                      //      ___________
#define KS0108_DI             PIN_B2   // Data/Instruction
#endif
 
#ifndef KS0108_RW                      //      _____
#define KS0108_RW             PIN_B4   // Read/Write
#endif
 
#ifndef KS0108_E
#define KS0108_E              PIN_B5   // Enable
#endif
 
#ifndef KS0108_RST
#define KS0108_RST            PIN_C0   // Reset
#endif
 
 
#define KS0108_CMD_ON         0x3F
#define KS0108_CMD_OFF        0x3E
#define KS0108_CMD_PAGE       0xB8
#define KS0108_CMD_COLUMN     0x40
#define KS0108_CMD_TOP_RAM    0xC0
 
 
#ifdef FAST_GLCD
int8 displayData[512];
#endif
 
 
void KS0108_init(int1 mode);
void KS0108_fill(data);
void KS0108_pixel(int8 x, int8 y, int1 color);
int8 KS0108_status();
void KS0108_write(int8 data);
int8 KS0108_read();
 
 
// Purpose:    Specify the row appearing at the top of the screen
// Inputs:     The row number (0 - 63)
#define KS0108_topRow(row)     KS0108_write(KS0108_CMD_TOP_RAM | row)
 
 
// Purpose:    Turn the display on
#define KS0108_on()            KS0108_write(KS0108_CMD_ON)
 
 
// Purpose:    Turn the display off
#define KS0108_off()           KS0108_write(KS0108_CMD_OFF)
 
 
// Purpose:    Set the page number
// Inputs:     A page number (0 - 7)
#define KS0108_page(page)      KS0108_write(KS0108_CMD_PAGE | page)
 
 
// Purpose:    Set the column address
// Inputs:     The column address (0 - 63)
#define KS0108_column(column)  KS0108_write(KS0108_CMD_COLUMN | column)
 
// Purpose:    Specify reads and writes are instructions
#define KS0108_inst()          output_low(KS0108_DI);
 
 
// Purpose:    Specify reads and writes are data
#define KS0108_data()          output_high(KS0108_DI);
 
 
// Purpose:    Initialize the display controller
// Inputs:     TRUE  - Initialize with the display on
//             FALSE - Initialize with the display off
void KS0108_init(int1 mode)
{
   // Initialze some pins
   output_high(KS0108_RST);
   output_low(KS0108_E);
   output_low(KS0108_CS);
 
   KS0108_inst();             // Set for instruction
   KS0108_topRow(0);          // First RAM line at the top of the screen
   KS0108_page(0);            // Set the page address to 0
   KS0108_column(0);          // Set the column address to 0
 
   if(mode)
      KS0108_on();            // Turn the display on
   else
      KS0108_off();           // Turn the display off
 
   KS0108_fill(0);            // Clear the display
}
 
 
// Purpose:    Fill a display with a vertical byte pattern
// Inputs:     The byte of data to fill with
void KS0108_fill(data)
#ifdef FAST_GLCD
{
   int16 i;
 
   for(i=0; i<512; ++i)
   {
      displayData[i] = data;
   }
}
#else
{
   int8 i, j;
 
   // Loop through the vertical pages
   for(i = 0; i < 8; ++i)
   {
      KS0108_inst();          // Set for instruction
      KS0108_page(i);         // Set page address
      KS0108_column(0);       // Set horizontal address to 0
      KS0108_data();          // Set for data
 
      // Loop through the horizontal sections
      for(j = 0; j < 64; ++j)
      {
         KS0108_write(data);  // Write the byte of data
      }
   }
}
#endif
 
 
// Purpose:    Turn the pixel at (x,y) on or off
// Inputs:     1) The x coordinate (0 - 63)
//             2) The y coordinate (0 - 63)
//             3) TRUE turns the pixel on, FALSE turns the pixel off
void KS0108_pixel(int8 x, int8 y, int1 color)
#ifdef FAST_GLCD
{
   int16 index = 64;
   index *=  y/8;
   index += x;
 
   if(color)
   {
      bit_set(displayData[index], y%8);
   }
   else
   {
      bit_clear(displayData[index], y%8);
   }
}
#else
{
   int8 data;
 
   KS0108_inst();             // Set for instruction
   KS0108_column(x);          // Set the horizontal address
   KS0108_page((y/8));        // Set the page address
   KS0108_data();             // Set for data
   KS0108_read();             // Need two reads to get data at new address
   data = KS0108_read();
 
   if(color)
      bit_set(data, y%8);     // Turn the pixel on
   else                       // or
      bit_clear(data, y%8);   // turn the pixel off
 
   KS0108_inst();             // Set for instruction
   KS0108_column(x);          // Set the horizontal address
   KS0108_data();             // Set for data
   KS0108_write(data);        // Write the pixel data
}
#endif
 
 
// Purpose:    Update the LCD with data from the display array
#ifdef FAST_GLCD
void KS0108_update()
{
   int8 i, j;
   int8 *p;
   
   p = displayData;
 
   // Loop through the vertical pages
   for(i = 0; i < 8; ++i)
   {
      KS0108_inst();          // Set for instruction
      KS0108_page(i);         // Set page address
      KS0108_column(0);       // Set horizontal address to 0
      KS0108_data();          // Set for data
 
      // Loop through the horizontal sections
      for(j = 0; j < 64; ++j)
      {
         KS0108_write(*p++);  // Write the byte of data
      }
   }
}
#endif
 
 
// Purpose:    Read the status register
// 7:    0 - Ready   1 - Busy
// 6:    0
// 5:    0 - On      1 - Off
// 4:    0 - Normal  1 - Reset
// 3-0:  0
int8 KS0108_status()
{
   KS0108_inst();             // Set for instruction
   return KS0108_read();      // Read and return the status
}
 
 
// Purpose:    Write a byte to the specified chip
// Inputs:     The byte to write
// Note:       Specify instruction or data before calling
void KS0108_write(int8 data)
{
   output_high(KS0108_CS);    // Raise the chip select
   output_low(KS0108_RW);     // Set for writing
   output_d(data);            // Write to the data bus
   delay_cycles(2);
   output_high(KS0108_E);     // Pulse the enable pin
   delay_cycles(10);
   output_low(KS0108_E);
   output_low(KS0108_CS);     // Lower the chip select
   delay_cycles(10);
}
 
 
// Purpose:    Reads a byte of data from the specified chip
// Ouputs:     A byte of data read from the chip
// Note:       Specify instruction or data before calling
int8 KS0108_read()
{
   int8 data;                 // Stores the data read from the LCD
 
   set_tris_d(0xFF);          // Set port d to input
   output_high(KS0108_CS);    // Raise the chip select
   output_high(KS0108_RW);    // Set for reading
   delay_cycles(2);
   output_high(KS0108_E);     // Raise the enable pin
   delay_cycles(10);
   data = input_d();          // Read from the data bus
   output_low(KS0108_E);      // Lower the enable pin
   output_low(KS0108_CS);     // Lower the chip select lines
   delay_cycles(10);
 
   return data;               // Return the read data
}
 
#endif

pajaro · « **Respuesta #10 en:** 21 de Agosto de 2009, 14:00:41 »

LCDg01

pajaro · « **Respuesta #11 en:** 21 de Agosto de 2009, 14:01:02 »

LCDg02

pajaro · « **Respuesta #12 en:** 21 de Agosto de 2009, 14:02:24 »

LCDg03

MLO__ · « **Respuesta #13 en:** 21 de Agosto de 2009, 15:41:26 »

Ojo con las librerias originales del CCS, tienen copyright.

TODOPIC

Autor Tema: Desmenuzar un drivers de LCD - CCS (Leído 10448 veces)

pajaro

Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

pajaro

Re: Desmenuzar un drivers de LCD - CCS

MLO__

Re: Desmenuzar un drivers de LCD - CCS