Cómo conectar un display LCD a tu Raspberry-Pi

En este post Mark Wiliams  nos muestra con  todo detalle   cómo conectar y utilizar un display de   16 x 2 LCD en modo 4 bits sobre una Raspberry Pi usando la  librería WiringPi que permite programar de forma fácil dispositivos externos.

El LCD  usando es un display  OLED azul (LCD) de 16 × 2 de adafruit basado en el clásico HD44780 de Hitachi ,el cual es un standard «de facto » en cuanto a displays lcd alfanumericos.

Esta modelo de pantalla cuenta con ultra-alto contraste  ,mayor incluso que las clásicas pantallas LCD restroliluminadas, por lo que la legibilidad es excelente desde cualquier ángulo.

El LCD ,como  adelantaba utiliza el controlador HD44780 el cual  está presente en casi todas las pantallas LCD.Como es habitual en este tipo de displays que utilizan este controlador por lo general tienen 14 ó 16 pines. (En etse caso elLCD tiene 16, numerados del 0 al 16)
A veces, todos estos pines están presentes, pero alguno  no se utiliza,por ejemplo, los pines 15 y 16 son para back-light que en este modelo no se utilizan
PINES DEL HD44780  EN DETALLE
Pin 1 Ground.
Pin 2 Tensión de alimentación de OLED y la lógica
Pin 3 Por lo general está conectado a un potenciómetro para controlar el contraste de la pantalla.
Pin 4 La señal de selección de registro (RS) determina si los valores de los bits de datos se interpretan como una orden (la pantalla del claro ejemplo) o los datos (aka: un personaje para mostrar).
Pin 5 ¿La lectura / escritura pin. En el modo de lectura, este pin se utiliza para obtener información de la pantalla LCD para averiguar si la pantalla LCD se puede aceptar comandos o para indicar que está demasiado ocupado.
No necesitamos esta función podemos esperar el tiempo máximo de una orden que debe ser por escrito (200us) antes de enviar el siguiente comando.
Si la lectura está activada y Pin4 en la pantalla LCD está conectado a un pin en el Raspberry Pi, hay una posibilidad de que pueda destruir su Pi. Sólo quiero volver a escribir en el LCD, nunca queremos leer de él. Así que esto siempre debe estar conectado a tierra.
Pin 6 La patilla de habilitación (E) funciona como el comando / data enclavamiento de señales para la pantalla LCD. La pantalla LCD se enganchará en lo que está en los bits de datos y procesarlos en el flanco descendente de la señal E
Es decir, cuando este pin va de baja, la pantalla LCD se llevará a la entrada de los pines de datos en este momento.
Clavijas 7 y 14 Son los pines de datos. En el modo de pin 4, sólo se usan los pines 11 a 14.
Los contactos 15 y 16 Se utilizan para la luz de fondo si está presente.

Cableado del LCD   a tu Raspberry

A continuación se muestra cómo conectar el LCD a la Raspberry Pi. Vamos a utilizar el modo de pin 4, así que no hay necesidad de conectar los pines 7 a 10. Este LCD no utiliza los pines de luz de fondo, pines 15 y 16 . Asimismo,en el ejemplo tampoco se utiliza el pin de contraste, pin 3.

Código

En el pasado, usted habría tenido que conocer los registros utilizados por el controlador para configurar la pantalla, coloque el cursor o incluso escribir un carácter único.Hoy en día todo esto e ha simplifico muchísimo , que en el caso de la Raspberry gracias a la librería  WiringPi .

Instalación WiringPi;

@ raspberrypi pi ~ $ sudo apt-get update
@ raspberrypi pi ~ $ git clone git :/ / git.drogon.net / wiringPi
@ raspberrypi pi ~ $ cd wiringPi
@ raspberrypi pi ~ $ git pull origen
@ raspberrypi pi ~ $. / build

El código siguiente es un ejemplo muy simple de mostrar un poco de texto en la línea superior de la pantalla LCD. Hay una lista completa de todas las funciones de la biblioteca en el LCD WiringPi sitio web.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <wiringPi.h>           //WiringPi headers
#include <lcd.h>                //LCD headers from WiringPi
#include <stdio.h>              //Needed for the printf function below
//Pin numbers below are the WiringPi pin numbers
#define LCD_RS  3               //Register select pin
#define LCD_E   0               //Enable Pin
#define LCD_D4  6               //Data pin 4
#define LCD_D5  1               //Data pin 5
#define LCD_D6  5               //Data pin 6
#define LCD_D7  4               //Data pin 7
int main()
{
    int lcd;                //Handle for LCD
    wiringPiSetup();        //Initialise WiringPi
    //Initialise LCD(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
    if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
            printf ("lcdInit failed! \n");
            return -1 ;
    }
    lcdPosition(lcd,0,0);           //Position cursor on the first line in the first column
    lcdPuts(lcd, "Character LCD");  //Print the text on the LCD at the current cursor postion
    getchar();                      //Wait for key press
    lcdClear(lcd);                  //Clear the display
}
Lineas 1 y 2 se requieren ya que estos son los encabezados de la biblioteca LCD WiringPi.
Líneas 7 y 12 son las definiciones de los pines utilizados para conectar el LCD a la Raspberry Pi. Los números de pin se puede encontrar aquí.
Línea 21 sirve para  inicializar el LCD con LCDINIT ()
Los argumentos usados en la funcion lcdint() son:;
(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
rows = Numero de filas del  LCD
cols = Numero de columnas del  LCD
bits = Numeros de bits usados como datos (   8 o 4).
rs = Pin de seleccion
enable =  pin activacion
d0-d7 = modo 8 o 4 bit modo. In modor 4 bit,solamente  usar  pins desde d0 a d3( como en todosl los displays HD44780). Si se utiliza el modo de 8 bits, es necesario especificar los pins del d0 a d7. En el código de ejemplo anterior, estamos utilizando el modo de 4 bits.El código siguiente es lo que se utiliza en el vídeo en la parte inferior de este post

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <wiringPi.h>
#include <lcd.h>
#include <string.h>
#include <time.h>
char level0[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111};
char level1[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111};
char level2[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111};
char level3[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111};
char level4[8] = { 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level5[8] = { 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level6[8] = { 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level7[8] = { 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
#define COLUMNS 16
#define LCD_RS  3
#define LCD_E   0
#define LCD_D4  6
#define LCD_D5  1
#define LCD_D6  5
#define LCD_D7  4
void uptime(void);
void memory(void);
void volume(void);
void scrollText(void);
void INThandler(int sig);
int mymillis(void);
char message[] = "WWW.MARKS-SPACE.COM";
int count =0;
int j = 0;
FILE *uptime_file, *mem_file;
char *temp;
int lcd;
int main()
{
signal(SIGINT, INThandler);
wiringPiSetup () ;
if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
printf ("lcdInit failed! \n");
return -1 ;
}
int uptimeTimer;
while(1){
lcdClear (lcd);
volume();
sleep(1);
memory();
sleep(4);
lcdClear (lcd);
uptimeTimer  = mymillis();
while ((mymillis() - uptimeTimer) < 5000)
uptime();
sleep(1);
lcdClear (lcd);
scrollText();
}
}
void uptime(void)
{
unsigned int uptime_unsorted = 0;
unsigned char c;
unsigned int DD;
unsigned int HH;
unsigned int MM;
unsigned int SS;
uptime_file=fopen("/proc/uptime","r");
if(NULL != uptime_file)
{
while((c=fgetc(uptime_file))!= '.')
{
unsigned int i;
i = atoi(&c);
uptime_unsorted = (uptime_unsorted * 10) + i;
}
SS = uptime_unsorted % 60;
MM = uptime_unsorted / 60 % 60;
HH = uptime_unsorted / 60 / 60 % 24;
DD = uptime_unsorted / 60 / 60 / 24;
printf("\x1B[2J");
printf("Uptime:D%i,%02i:%02i:%02i\n",DD,HH,MM,SS);
lcdPosition(lcd,0,0);
lcdPrintf(lcd,"Uptime:  Days %i", DD);
lcdPosition(lcd,4,1);
lcdPrintf(lcd,"%02i:%02i:%02i",HH,MM,SS);
}
else
{
printf("Open file \"proc/uptime\" failed!\n");
}
void memory(void)
{
char MemTotal[35];
char MemFree[35];
char total[35];
char free[35];
lcdClear (lcd);
mem_file=fopen("/proc/meminfo","r");
if(NULL != mem_file)
{
fscanf(mem_file,"%*s%s%*s", MemTotal);
fscanf(mem_file,"%*s%s%*s", MemFree);
printf("\x1B[2J");
lcdPosition(lcd,0,0);
lcdPrintf(lcd,"MemTotal-%sk",MemTotal);
lcdPosition(lcd,0,1);
lcdPrintf(lcd,"MemFree -%sk",MemFree);
fclose(mem_file);
}
else
{
printf("Open file \"/proc/meminfo\" failed!\n");
}
}
void volume(void)
{
//Defined custom characters for volume display
lcdCharDef  (lcd, 0, level0);
lcdCharDef  (lcd, 1, level1);
lcdCharDef  (lcd, 2, level2);
lcdCharDef  (lcd, 3, level3);
lcdCharDef  (lcd, 4, level4);
lcdCharDef  (lcd, 5, level5);
lcdCharDef  (lcd, 6, level6);
lcdCharDef  (lcd, 7, level7);
lcdClear (lcd);
int i;
lcdPosition (lcd, 9,1);
lcdPuts (lcd, ":Volume");
for (i = 0; i < 7; i++){
lcdPosition (lcd, i, 1);
lcdPutchar  (lcd, i);
usleep(400000);
}
}
void  scrollText(void)
{
int i,n;
int h ;
int tempSpace = 0;
char scrollPadding[] = "                   ";
int messageLength = strlen (scrollPadding)+strlen(message);
for (n=0;n<messageLength;n++){
h = COLUMNS;
usleep(300000);
printf("\x1B[2J");
if ( j > messageLength )
j = 0;
for (i = 0  ; i  < j ; i ++){
scrollPadding[h-j] = message[i];
h++;
}
lcdPosition(lcd,0,0);
lcdClear (lcd);
lcdPrintf(lcd,"%s",scrollPadding);
j++;
}
}
void  INThandler(int sig)
{
lcdClear (lcd);
fclose(uptime_file);
signal(sig, SIG_IGN);
exit(0);
}
int mymillis(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (tv.tv_sec) * 1000 + (tv.tv_usec)/1000;
}

Y por último en este vídeo podemos  ver el excelente rendimiento que ofrece este display con nuestro Raspberry Pi

Fuente  aquí

🤞 No se pierda nuestro boletín mensual !es gratis!

¡No hacemos spam! Más información en nuestra política de privacidad

0 comentarios en “Cómo conectar un display LCD a tu Raspberry-Pi

  1. hola carlos. queria una pequeña pregunta? tengo una lcd monocromoverde 61×2 hitachi pero de 14 pines que saque, haciendo mis chapus, de una maquina de escribir electrónica antigua, tiene el chip 3l1 hd44780a95 japan y un chip pequeño smt en la placa pone LM736. ¿ los 2 pines que faltan, respecto a una de 16 pines, son los de contraste de brillo esos que no se conectan? ¿se conecta igual que una de 16 pines? quiero probarla en mi arduino uno rev 3 pero todavía tengo duda.
    gracias saludos
    oscar

    1. Hola Oscar!
      En un porcentaje muy alto la mayoría de los displays lcd antiguos y también modernos llevan el chip hitachi hd44780 o alguno equivalente a este , así que creo estas de suerte porque con el lcd deberias poder comunicarte con las librerias standard de Arduino.
      Otro tema muy distinto son el pinout de la placa del lcd que por desgracia no siempre se respeta a pesar de tener el mismo chip debido a que no todos los fabricantes conectan los terminales de la misma manera, pero lo normal es que si se siga también la norma.!!mucho cuidado con el orden de los pines!!

      Respecto al diferencia de 14 a 16 pines se debe a que no todos los displays cuentan con retroliluminación por leds así que si el tuyo solo tiene 14 pines se deba a esto .
      Ojo si alguna vez tienes un lcd de 16 pines pues en los dos pines ultimos pines no se conectan directamente a 5V sino a una resistencia cuyo valor dependera de los leds que tenga el lcd.

      Por ultimo si el cuerpo del cristal del lcd es delgado(40 o 50mm) es señal que no tiene retroiluminacion pues los que lo incluyen suelen ser mucho mas gruesos..

Deja una respuesta