PicManía by RedRaven
 

Búsqueda personalizada

 

PROYECTOS : AUX Display LCD

 

 

Circuito auxiliar de Display LCD con un CM16022A  para la RRBOARD2
 

 

Descripción:
 
  •  Al final acompaño el programa de test que he realizado y la modificación de la librería Flex_LCD_2 que es necesaria para su correcto funcionamiento.
 Para hacerla compatible con nuestra RRBOARD2 solo he realizado lo siguiente:
 
  • Conectar el Cable Plano CON-ML-10 de 10 pines con el siguiente pinout
     
    • RD1 -> RS
    • RD2 -> R/W
    • RD3 -> E
    • RD4 -> DB7
    • RD5 -> DB6
    • RD6 -> DB5
    • RD7 -> DB4
       
  • con lo que conseguimos controlar el LCD con sólo 7 pines (podríamos incluso ahorrarnos 1 pin más si conectamos a GND el terminal R/W del LCD)
Recursos:
 
Circuito:
 
  •  El diseño es como puede verse muy simple y fácil de implementar, tanto que lo he realizado sobre una placa PCB taladrada.

 

Fotografías:
 


 


 

Software:
 

 

 
lcd_232_2.c
 
 
 
#include <18f4550.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

// Control del LCD con flex_lcd_2 -----------------------------------
//
// flex_lcd_2 funciona en modo 4 bits con DB4 a DB7 (DB0 a DB3 a GND)
// definir a continuación qué pines del PIC corresponden a DB4 a DB7

#define LCD_DB4 PIN_D7
#define LCD_DB5 PIN_D6
#define LCD_DB6 PIN_D5
#define LCD_DB7 PIN_D4

// si solo va a utilizar escritura en el LCD conecta R/W a GND y
// comente la siguiente línea

#define USE_LCD_RW 1

// definir a continuación qué pines del PIC manejan las señales de control

#define LCD_RS PIN_D1
#define LCD_RW PIN_D2
#define LCD_E PIN_D3

// funciones definidas en flex_lcd_2 disponibles para el usuario
//
// lcd_init() imprescindible ejecutarla antes de usar el LCD
// lcd_setcursor(V,P) Cursor visible si V=1, invisible si V=0, Cursor parpadeando si P=1, fijo si P=0
// lcd_gotoxy(x,y) posiciona el cuarsor en el caracter x (1..16) de la línea y (1..2)
// lcd_putc(c) muestra el caracter c en la posicion actual del cursor y avanza éste 1 posicion
// Caracteres especiales:
// \f -> limpia la pantalla y posiciona el cursor en caracter 1 de la linea 1
// \n -> posiciona el cursor en caracter 1 de la linea 2
// \b -> restrocede el cursor una posicion
// \t -> avanza el cursor una posicion
// lcd_put_string(*ps) muestra el texto ps, caracter a caracter incluidos los especiales, a partir de
// de la posicion actual del cursor. Ha de ser una variables no una constante.
// lcd_put_string_xy(*ps,x,y) combina lcd_gotoxy y lcd_put_string en una sola función


// Include de la librería flex_lcd_2

#include "flex_lcd_2.c"

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

char Keypress=0x00;
char Text1[]="\fTEST LCD\nEN RRBOARD2";
char Text2[]="ABC";

#int_rda
  void serial_isr() {

  Keypress=0x00;
  if(kbhit()){
    Keypress=getc();
    putc(Keypress);
  }
}

void main() {

  printf("\r\n\LCD on RRBOARD2\r\n\n");

  lcd_init();
  lcd_setcursor(0,0);
  lcd_put_string(Text1);
  lcd_gotoxy(1,2);

  enable_interrupts(int_rda);
  enable_interrupts(global);

  do {

    if(Keypress!=0x00){

      if(Keypress==0x0d){
        lcd_put_string_xy(Text2,10,1);
      }
      else{
        lcd_putc(Keypress);
      }
      Keypress=0x00;
    }

  } while (TRUE);

}
   
 
 

Descargar lcd_232_2.c

 

 

 
flex_lcd_2
 
 
  // flex_lcd_2.c

//#define LCD_DB4 PIN_B4
//#define LCD_DB5 PIN_B5
//#define LCD_DB6 PIN_B6
//#define LCD_DB7 PIN_B7
//
//#define LCD_RS PIN_C0
//#define LCD_RW PIN_C1
//#define LCD_E PIN_C2

// 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
}
delay_ms(15);
}

//----------------------------
// Posiciones válidas:
// de x=1 a x=16 y
// de y=1 a y=2

void lcd_gotoxy(int8 x, int8 y){

int8 address;

if(x > 0 && y > 0){
if(y > 1)
address = lcd_line_two;
else
address=0;

address += x-1;

lcd_send_byte(0, 0x80 | address); // Manda cursor a la posición
}
}

//-----------------------------
void lcd_putc(char c)
{


/*' LCD
' Command Operation
' *********** *****************************************
' $FE, 1 Clear display
' $FE, 2 Return home
' $FE, $0C Cursor off
' $FE, $0E Underline cursor on
' $FE, $0F Blinking cursor on
' $FE, $10 Move cursor left one position
' $FE, $14 Move cursor right one position
' $FE, $80 Move cursor to beginning of first line
' $FE, $C0 Move cursor to beginning of second line
' *********** ***************************************** */

if(c>'\0'){
switch(c){

case '\f':
lcd_send_byte(0,1);
lcd_send_byte(0,2);
delay_ms(2);
break;

case '\n':
lcd_gotoxy(1,2);
delay_ms(2);
break;

case '\b':
lcd_send_byte(0,0x10);
delay_ms(2);
break;

case '\t':
lcd_send_byte(0,0x14);
delay_ms(2);
break;

default:
lcd_send_byte(1,c);
delay_ms(2);
break;
}
}
}

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

void lcd_put_string(char *string){
//put string, starting from the curren cursor position
//assume that string not excides from lcd displayed RAM
char index=0;

while(string[index]!=0){
lcd_putc(string[index++]);
}
}


//------------------------------
void lcd_put_string_xy(char *string, char x, char y){
//assume that string not excides from lcd displayed RAM
lcd_gotoxy(x,y);
lcd_put_string(string);
}


//------------------------------
#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

//------------------------------
void lcd_setcursor(short visible, short blink) {
lcd_send_byte(0, 0xC|(visible<<1)|blink);
}
   
 
 

Descargar flex_lcd_2.c

 
 
 
PCB's en PDF Listos para imprimir.

 

Esta página se modificó el 27/12/2008


Esta página usa la letra Ñ

Nota pública importante sobre las consultas al Webmaster de PicManía.


Sugerencias a Picmanía... (que serán leídas pero seguramente no podrán ser contestadas)

Esta página pertenece al grupo de páginas de Diego RedRaven

 

 



Nota: Esta página Web esta repleta de imágenes, textos, logotipos y demás material extraídos de los mas variados medios de los que no soy ni autor ni depositario de los correspondientes derechos de autor, uso y/o reproducción. Si Ud. es depositario de dichos derechos y desea que el material correspondiente sea eliminado de esta Web no dude en ponerse en contacto conmigo mediante e-mail y será inmediatamente retirado. Gracias.
 
Visitas
Totales : 14995 Hoy: 1 Activas: 1 Vistas: 14995

Esta página fue modificada el 07-08-2010 15:41:25

           
 DmSoft WAMP Escribir Unreal