Texto en movimiento en un LCD con Arduino

Comentarios(27)
Luis del Valle Hernández

Dentro de la computación física, tenemos sensores y actuadores. Estos

componentes son las interfaces hardware que ponen en contacto el mundo
físico con el mundo virtual. Al igual que con los ordenadores tenemos
teclado, ratón, altavoces, etc…, con las placas microcontroladoras como
Arduino, tenemos hardware que harán la misma función. En este caso
vamos a ver un actuador, una pantalla LCD con Arduino.

Este componente se encarga de convertir las señales eléctricas de la placa

en información visual fácilmente entendible por los seres humanos.
Debemos de dominar tanto la conexiones como la programación de la
pantalla LCD con Arduino ya que es un componente muy útil en
muchos proyectos. La gran ventaja es que gracias a la pantalla LCD,
podremos mostrar información de datos como temperatura, humedad,
presión o voltaje.

Indice de contenidos
 1 LCD Liquid Crystal Display
 2 Conexiones de un LCD con Arduino
 3 Ejemplo básico LCD con Arduino
 4 Moviendo el texto horizontalmente en un LCD con Arduino

LCD Liquid Crystal Display

LCD es el acrónimo de Liquid Crystal Display (en español Pantalla de
Cristal Líquido). No podemos considerar que se trate de una tecnología
novedosa. El LCD lleva con nosotros mucho tiempo, solo tenemos que
echar la mirada hacia atrás y recordar esos relojes Casio o las
calculadoras que llevamos a clase de matemáticas.

Estamos acostumbrados a que la materia pueda estar en estado sólido,

líquido o gaseoso, los llamados estados de la materia. Pero ya en el siglo
XIX se descubrió que había más estados en los que podía encontrarse la
materia. El cristal líquido se encuentra en algún lugar entre el sólido y
líquido.

¿Quieres montar tu primer proyecto con Arduino?

Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso
a paso y en sólo una semana.

UNIRSE AL CURSO
Aceptas que almacene tu nombre y email para poder enviarte
información de Programarfacil.
No es el objetivo de este artículo explicar la física involucrada detrás de
los LCD, solo decir que utiliza las propiedades de la luz polarizada para
mostrarnos la información en una pantalla. A partir de una serie de filtros,
se consigue mostrar la información gracias a la iluminación de fondo.

Hay una amplia gama de pantallas LCDs que podemos utilizar con Arduino.
Aparte de las funcionalidades extra que nos puedan dar cada una de ellas,
las podemos diferenciar por el número de filas y columnas, su tamaño.
Por ejemplo, una pantalla LCD de 16×1 tendrá una fila de 16 caracteres
es decir, solo podremos mostrar 16 caracteres simultáneamente, al igual
que un LCD de 20×4 tendrá 4 filas de 20 caracteres cada una.

En este artículo vamos a trabajar con un LCD típico, de 16×2. Esto significa
que vamos a poder mostrar 16 caracteres en la primera fila y los mismos en
la segunda fila.

Conexiones de un LCD con Arduino

La mayoría de las pantallas LCD que se están haciendo ahora, vienen con
una fila de dieciséis pines. Los primeros catorce pines se utilizan para
controlar la visualización. Los dos últimos son para la iluminación de fondo.

PIN FUNCIÓN

1 GND (Tierra)
2 5 Voltios

3 Control de contraste pantalla

4 RS – Selector entre comandos y datos

5 RW – Escritura y lectura de comandos y datos

6 Sincronización de lectura de datos

7-14 Pines de datos de 8-bit

15 Alimentación luz de fondo (5V)

16 GND (Tierra) luz de fondo (0V)

En la siguiente imagen te muestro la correspondencia con los pines físicos

del LCD.
Esta imagen muestra la parte de abajo del LCD. Cuando lo conectes a la
protoboard los pines estarán invertidos horizontalmente.

Montando el circuito
Una vez conocemos los conectores, ya podemos montar el circuito básico.
El material que vamos a utilizar es el siguiente

 Arduino UNO o similiar

 Protoboard
 Cables
 Pantalla LCD 16X2
 Potenciómetro de 10 kΩ
 Resistencia 200 Ω

En la siguiente imagen te muestro cómo hacer el cableado.

Como puedes comprobar, el circuito es muy sencillo. La resistencia de
200 Ω permite regular el voltaje a la entrada de la alimentación del LCD.
El potenciómetro se utiliza para regular el contrastes de la pantalla.

Es muy importante que el potenciómetro sea de 10 kΩ. Los

potenciómetros son resistencias variables es decir, que cambian el valor
de resistencia al girar un regulador.

Ejemplo básico LCD con Arduino

Para programar con el código nativo de Arduino, vamos a utilizar una
librería que nos hará más fácil el desarrollo. Esta librería
es LiquidCrystal.h. No hace falta instalarla en el entorno de desarrollo
oficial ya que viene por defecto. Lo único que tenemos que hacer es
añadirla como un include en nuestro programa o sketch. Vamos a ver un
ejemplo muy simple donde escribamos un texto en el LCD.

En este ejemplo vamos a escribir la frase “Hola Mundo!!!!!!” en la primera

fila y “Probando el LCD” en la segunda fila. Vamos a ir viendo el código
parte por parte así quedará más claro.

Importaciones, declaraciones de constantes y

variables
Importamos la librería LiquidCrystal.h

1 // Incluímos la libreria externa para poder utilizarla

2 #include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada

La librería LyquidCrystal.h no es exclusiva para un LCD de 16×2. También

puede ser utilizada por otro tipo de LCDs con diferente número de filas y
columnas. En las siguientes líneas de código vamos a definir dos
constantes que nos indiquen las filas y columnas de nuestro LCD.

1 // Definimos las constantes

2 #define COLS 16 // Columnas del LCD

3 #define ROWS 2 // Filas del LCD

Una vez incluida, debemos indicar los pines que vamos a utilizar para
enviar los datos. esto lo hacemos a través del
constructor LyquidCrystal(…). Esta función permite diferente número de
parámetros que dependerá de la configuración que estemos utilizando. En
la llamada más básica, la que vamos a utilizar, debemos pasar como
parámetros el RS, la sincronización, y los 4 pines para enviar datos. La
función quedaría de la siguiente manera LyquidCrystal(RW,
sincronización, d4, d5, d6, d7). Si sustituimos estos datos con los pines de
Arduino tenemos lo siguiente.
1 // Lo primero is inicializar la librería indicando los pins de la interfaz

2 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Donde 12 es el pin de Arduino donde hemos conectado el pin RW, el pin

11 es el de sincronización y el 5, 4, 3 y 2 son los pines correspondientes a
los datos.

La palabra lcd es el nombre que le vamos a dar a esta variable (clase).

Este nombre puede ser modificado siguiendo las reglas del lenguaje y no
utilizando palabras reservadas.

Función setup()
Con esto ya podemos pasar a la función setup(). Esta función nos sirve
para hacer una configuración inicial en nuestros programas. Lo primero
que hacemos es configurar el monitor serie y luego inicializamos la interfaz
del LCD con Arduino y especificamos las dimensiones (16 columnas y 2
filas).

1 void setup() {

2 // Configuración monitor serie

3 Serial.begin(9600);

5 // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas

6 lcd.begin(COLS, ROWS);

7}

Función loop()
Ahora ya podemos empezar a escribir en la pantalla del LCD. Para ello
vamos a utilizar tres métodos:

 clear(): limpia la pantalla.

 setCursor(columna, fila): sitúa el cursor en una columna y una fila
para después escribir a partir de esa posición.
 print(datos): escribe en la posición definida por setCursor(columna,
fila) los datos. Normalmente los datos son una cadena de caracteres
(String).
 setCursor comienza desde 0 es decir, si queremos escribir en la columna
1 fila 1 debemos poner setCursor(0,0). Esta característica de un lenguaje
se suele llamar índice cero (del inglés zero index).
Comenzamos la función loop(…) donde lo primero que hacemos es limpiar
el LCD, situar el cursor en la columna 0 (sería la primera columna) y la fila
0 (sería la primera fila). Por último escribimos el primer texto “Hola
Mundo!!!!!!”.

1 void loop() {

2 // Limpiamos la pantalla

3 lcd.clear();

5 // Situamos el cursor en la columna 0 fila 0

6 lcd.setCursor(0,0);

8 // Escribimos Hola Mundo!!!!!!

9 lcd.print("Hola Mundo!!!!!!");

Para escribir el segundo texto, tenemos que mover el cursor a la nueva

posición. Queremos que se sitúe justo debajo así que movemos a la
siguiente fila (fila 1 que corresponde con la segunda fila) y la columna será
la 0 (primera columna). Después escribimos el texto. Por último ponemos
un delay() (esperar un tiempo) más que nada para que no esté
constantemente mandando datos. Esto último no sería necesario.

1 // Situamos el cursor en la columna 0 fila 1

2 lcd.setCursor(0,1);

4 // Escribimos Probando el LCD.

5 lcd.print("Probando el LCD.");

7 // Esperamos 2 segundos igual a 2000 milisegundos

8 delay(2000);

9}

Entre las dos llamadas de la función print(), no se realiza el clear ya que

esto supondría borrar lo anteriormente escrito.

Moviendo el texto horizontalmente en un

LCD con Arduino
En el siguiente ejemplo vamos a ver cómo podemos mover el texto de
forma horizontal. Para realizar este ejemplo es importante tener ciertos
conocimientos de programación ya que vamos a utilizar bucles de
repetición y funciones de caracteres. El fin es poder desplazar un texto en
horizontal de izquierda a derecha en la fila 1 (índice 0) y de derecha a
izquierda en la fila 2 (índice 1).

El algoritmo
Antes de empezar a programar, es conveniente plantear el algoritmo. Esto
nos ahorrará tiempo a la hora de codificar con el lenguaje nativo de
Arduino. Desarrollaremos la idea en sucesivos pasos bien estructurados
y ordenados. En este punto, no hay que profundizar en cuántas variables
o constantes necesito. Lo único que debemos plasmar son la secuencia
de pasos.

1. Obtenemos el tamaño del texto

2. Entrada del texto por la derecha primera fila
1. Bucle recorriendo los caracteres de mayor a menor índice
1. Obtenemos un trozo de la subcadena desde el índice hasta
el final
2. Limpiamos LCD
3. Situamos el cursor en la columna 0 fila 0
4. Mostramos trozo de texto en la pantalla del LCD
5. Esperamos tiempo
3. Desplazamiento de texto hacia la derecha primera fila
1. Bucle recorriendo todas las columnas desde la segunda hasta la
última más uno
1. Limpiamos LCD
2. Situamos el cursor en la columna correspondiente fila 0
3. Mostramos texto completo en la pantalla del LCD
4. Esperamos tiempo
 4. Desplazamiento de texto hacia la izquierda segunda fila
1. Bucle recorriendo las columnas desde la última más uno hasta
la columna 1
1. Limpiamos LCD
2. Situamos el cursor en la columna correspondiente fila 0
3. Mostramos texto completo en la pantalla del LCD
4. Esperamos tiempo
5. Salida de texto por la izquierda segunda fila
1. Bucle recorriendo los caracteres de menor a mayor índice
1. Obtenemos un trozo de la subcadena desde el índice hasta
el final
2. Limpiamos LCD
3. Situamos el cursor en la columna 0 fila 0
4. Mostramos trozo de texto en la pantalla del LCD
5. Esperamos tiempo

Es un algoritmo un poco complejo que se divide en 4 bloques. Los dos

primeros nos servirán para desplazar el texto hacia la derecha y los dos
siguientes para desplazarlo hacia la izquierda.

Código del texto en movimiento con LCD y Arduino

Una vez tenemos claro lo que queremos hacer, pasamos a traducirlo al
lenguaje de programación con Arduino. Es importante hacer el paso
anterior y, en este punto, te recomiendo que intentes hacerlo tu mismo.
Seguramente te equivocarás y no sabrás cómo hacerlo, pero a base de
practicar es como se adquiere la experiencia para poder desarrollar tus
propios proyectos.

¿Quieres montar tu primer proyecto con Arduino?

Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso
a paso y en sólo una semana.

UNIRSE AL CURSO
Aceptas que almacene tu nombre y email para poder enviarte
información de Programarfacil.
Declaración de constantes y variables
Lo primero es declarar las constantes y variables necesarias. Algunas ya
las hemos visto en el ejercicio básico. Para este ejemplo he añadido una
constante, VELOCIDAD, que nos permitirá controlar la velocidad de
desplazamiento del texto. Además he creado una variable del tipo
String que contendrá el texto que queremos desplazar.

1 // Incluímos la libreria externa para poder utilizarla

2 #include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada

4 // Definimos las constantes

5 #define COLS 16 // Columnas del LCD

6 #define ROWS 2 // Filas del LCD

7 #define VELOCIDAD 300 // Velocidad a la que se mueve el texto

9 // Lo primero is inicializar la librería indicando los pins de la interfaz

10 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

11

12 // Textos

13 String texto_fila = "Programarfacil.com";

Función setup()
La función setup() es exactamente igual que en el ejemplo básico.

1 void setup() {

2 // Configuración monitor serie

3 Serial.begin(9600);

5 // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas

6 lcd.begin(COLS, ROWS);

7}

Función loop()
Aquí es donde vamos a tener toda la lógica para mostrar el texto en
movimiento. Vamos a ir viendo parte por parte con la explicación necesaria
para que entiendas cómo lo he hecho. Lo primero que hacemos es obtener
el tamaño del texto es decir, el número de caracteres que tiene nuestro
texto. Para ello utilizamos la función length() que nos devuelve un número
entero indicando su tamaño.

1 void loop() {

3 // Obtenemos el tamaño del texto

4 int tam_texto=texto_fila.length();

La función length() nos devuelve el número de caracteres de un texto. Si

queremos recorrer todos los caracteres empezaremos por 0 y acabaremos
en número de caracteres – 1. Característica de los lenguajes índice cero.
En la siguiente parte vamos a mostrar cómo entra el texto por la parte
derecha. En esta parte no vamos a trabajar con el LCD ya que siempre se
encontrará en la misma posición, columna 0 fila 0. El truco está en ir
cogiendo trozos de texto, de más pequeño a más grande, y mostrarlos en
el LCD. Esto nos dará la sensación de que se está moviendo hacia la
derecha aunque en realidad lo que hacemos es mostrar cada vez un texto
diferente.

1 for(int i=tam_texto; i>0 ; i--)

2 {

3 String texto = texto_fila.substring(i-1);

4
5 // Limpiamos pantalla

6 lcd.clear();

8 //Situamos el cursor

9 lcd.setCursor(0, 0);

10

11 // Escribimos el texto

12 lcd.print(texto);

13

14 // Esperamos

15 delay(VELOCIDAD);

16 }

La función substring(numero) nos devuelve un trozo del texto. El número

indica a partir de qué letra vamos a coger por ejemplo si hacemos “Hola
Mundo”.substring(2) nos devolverá “la Mundo”. Recuerda que es un
lenguaje de índice cero, el primer carácter del texto empieza por cero.
Ahora si que toca desplazar el texto. Para ello hacemos un simple bucle
que recorra todas las columnas del LCD. Además tenemos que forzar para
que la última visualización sea en la columna 17 y así simularemos que el
texto ha desaparecido por la derecha.

1 // Desplazamos el texto hacia la derecha

2 for(int i=1; i<=16;i++)

3 {

4 // Limpiamos pantalla

5 lcd.clear();

7 //Situamos el cursor

8 lcd.setCursor(i, 0);

10 // Escribimos el texto
11 lcd.print(texto_fila);

12

13 // Esperamos

14 delay(VELOCIDAD);

15 }

Una vez que ha desaparecido por la derecha, lo vamos a mover de

derecha a izquierda. Si te fijas en el código, es exactamente igual que en
los pasos anteriores. Lo único que cambia es como se recorren los bucles,
ahora en sentido contrario. Lo primero es desplazar el texto a través de la
función setCursor() e indicando en que posición mostrar el texto.

1 // Desplazamos el texto hacia la izquierda en la segunda fila

2 for(int i=16;i>=1;i--)

3 {

4 // Limpiamos pantalla

5 lcd.clear();

7 //Situamos el cursor

8 lcd.setCursor(i, 1);

10 // Escribimos el texto

11 lcd.print(texto_fila);

12

13 // Esperamos

14 delay(VELOCIDAD);

15 }

Por último, lo hacemos desaparecer por la izquierda. La idea es igual que

cuando lo hacemos aparecer por la derecha. En este caso lo que hacemos
es ir mostrando de más caracteres a menos caracteres. Esto da la
sensación de que estamos desplazando el texto hacia la izquierda.
1 // Mostramos salida del texto por la izquierda

2 for(int i=1; i<=tam_texto ; i++)

3 {

4 String texto = texto_fila.substring(i-1);

6 // Limpiamos pantalla

7 lcd.clear();

9 //Situamos el cursor

10 lcd.setCursor(0, 1);

11

12 // Escribimos el texto

13 lcd.print(texto);

14

15 // Esperamos

16 delay(VELOCIDAD);

17 }

Código completo
A continuación te dejo el código completo. Cualquier duda o sugerencia te
agradecería que dejaras un comentario en este artículo.

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

C++

// Incluímos la libreria externa para poder utilizarla

#include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada
// Definimos las constantes

#define COLS 16 // Columnas del LCD

#define ROWS 2 // Filas del LCD

#define VELOCIDAD 300 // Velocidad a la que se mueve el texto

// Lo primero is inicializar la librería indicando los pins de la interfaz

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Textos

String texto_fila = "Programarfacil.com";

void setup() {

// Configuración monitor serie

Serial.begin(9600);

// Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas

lcd.begin(COLS, ROWS);

void loop() {

// Obtenemos el tamaño del texto

int tam_texto=texto_fila.length();

// Mostramos entrada texto por la izquierda

for(int i=tam_texto; i>0 ; i--)

String texto = texto_fila.substring(i-1);

 // Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(0, 0);

// Escribimos el texto

lcd.print(texto);

// Esperamos

delay(VELOCIDAD);

// Desplazamos el texto hacia la derecha

for(int i=1; i<=16;i++)

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(i, 0);

// Escribimos el texto

lcd.print(texto_fila);

// Esperamos

delay(VELOCIDAD);

}
// Desplazamos el texto hacia la izquierda en la segunda fila

for(int i=16;i>=1;i--)

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(i, 1);

// Escribimos el texto

lcd.print(texto_fila);

// Esperamos

delay(VELOCIDAD);

// Mostramos salida del texto por la izquierda

for(int i=1; i<=tam_texto ; i++)

String texto = texto_fila.substring(i-1);

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(0, 1);

// Escribimos el texto

lcd.print(texto);
 // Esperamos

delay(VELOCIDAD);

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

// Incluímos la libreria externa para poder utilizarla

#include <LiquidCrystal.h> // Entre los símbolos <> buscará en la carpeta de librerías configurada

// Definimos las constantes

#define COLS 16 // Columnas del LCD

#define ROWS 2 // Filas del LCD

#define VELOCIDAD 300 // Velocidad a la que se mueve el texto

// Lo primero is inicializar la librería indicando los pins de la interfaz

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Textos

String texto_fila = "Programarfacil.com";

void setup() {

// Configuración monitor serie

 Serial.begin(9600);

// Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas

lcd.begin(COLS, ROWS);

void loop() {

// Obtenemos el tamaño del texto

int tam_texto=texto_fila.length();

// Mostramos entrada texto por la izquierda

for(int i=tam_texto; i>0 ; i--)

String texto = texto_fila.substring(i-1);

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(0, 0);

// Escribimos el texto

lcd.print(texto);

// Esperamos

delay(VELOCIDAD);

}
// Desplazamos el texto hacia la derecha

for(int i=1; i<=16;i++)

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(i, 0);

// Escribimos el texto

lcd.print(texto_fila);

// Esperamos

delay(VELOCIDAD);

// Desplazamos el texto hacia la izquierda en la segunda fila

for(int i=16;i>=1;i--)

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(i, 1);

// Escribimos el texto

lcd.print(texto_fila);

// Esperamos
 delay(VELOCIDAD);

// Mostramos salida del texto por la izquierda

for(int i=1; i<=tam_texto ; i++)

String texto = texto_fila.substring(i-1);

// Limpiamos pantalla

lcd.clear();

//Situamos el cursor

lcd.setCursor(0, 1);

// Escribimos el texto

lcd.print(texto);

// Esperamos

delay(VELOCIDAD);

LCD 16×2 por I2C con Arduino usando solo

dos pines
by Admin | May 29, 2017 | Tutoriales, Tutoriales Arduino | 6 comments
La pantalla LCD de 16×2 basada en el controlador HD44780 de Hitachi es un periférico muy
común, que se utiliza ampliamente en proyectos con arduino y microcontroladores en general,
sin embargo, es bien sabido por todo aquel entusiasta que ha incluido una en sus proyectos,
que este tipo de pantalla requiere muchos pines del microcontrolador para ser controlada,
debido principalmente a que utiliza un bus paralelo para comunicarse. Afortunadamente existe
una solución muy fácil y económica para este problema: un adaptador basado en el
PCF8574 que permite conectar la pantalla al arduino usando solamente dos lineas digitales
a través del bus I2C. Dichos pines, pueden además ser compartidos por otros periféricos
como el RTC o memorias EEPROM. En este artículo te explicamos como utilizar una
pantalla LCD 16×2 por I2C con Arduino de manera que puedas aprovechar mejor tus pines
de I/O.
 En la foto principal vemos el arduino UNO conectado a una pantalla LCD de 16 x 2
usando el bus I2C
Materiales Necesarios
Los materiales para esta experiencia pueden encontrarse en nuestra tienda virtual, hace falta
un poco de soldadura para poner a punto la pantalla con el adaptador I2C:
 Pantalla LCD 16×2 compatible con HD44780
 Adaptador para pantalla LCD I2C PCF8574
 Arduino UNO R3
 Cables tipo dupont Macho-Hembra
Preparación de la pantalla con el adaptador I2C
Para usar nuestra pantalla LCD 16×2 por I2C con Arduino el primer paso es soldar el
adaptador I2C en la parte de trasera de la pantalla. Al finalizar la soldadura, nuestro adaptador
debe verse de la siguiente manera:
Como se aprecia el adaptador para LCD 16×2 por I2C con Arduino nos permite ahorrar
bastante tiempo en las conexiones, pues ya incluye el potenciómetro para regular el contraste
de la pantalla. También incluye todo lo necesario para el funcionamiento del backlight (retro-
iluminación), pudiendo incluso controlar esta función a través de software. Si no queremos
soldar el adaptador a la pantalla, podemos utilizar un protoboard para realizar la conexión
entre ambas piezas, tal como se muestra a continuación.
Diagrama para conectar el LCD 16×2 por I2C
Una vez que tenemos soldado el adaptador I2C, hay que identificar los pines de I2C en la
tarjeta arduino que estemos usando. En el arduino UNO, los pines del bus I2C
corresponden con los analógicos A4 y A5. También los encontramos duplicados en la parte
 superior, cerca del conector USB y se etiquetan como SDA y SCL (por la parte de abajo del
PCB). Para realizar las conexiones con el Arduino te recomendamos revisar los mapas de
pines en este post y tener la versión impresa siempre a la mano.
Las conexiones se realizan de la siguiente forma con el arduino, como podemos ver estamos
usando los pines analógicos A4 y A5, aunque también se puede conectar a SDA y SCL cerca
del conector USB:

Librería para LCD 16×2 por I2C con Arduino

Para usar el LCD 16×2 por I2C con Arduino es necesario también agregar una librería a
nuestro IDE, de forma que este sepa como comunicarse con el chip PCF8574. Ya explicamos
en alguna ocasión como cargar una librería y comenzar a utilizarla, si tienes dudas
te recomendamos revisar el tutorial. Cabe aclarar que esta librería, así como el adaptador I2C
deben funcionar de forma correcta con las pantallas de 20×4.
Puedes descargar la librería desde la página oficial en Bitbucket (repo) o desde nuestro
servidor. A continuación dejamos los enlaces para cada una de las opciones.
 Descarga desde página oficial (repositorio bitbucket)
 Descarga desde nuestro servidor
La librería LiquidCrystal_I2C dispone de métodos similares (algunos idénticos) a los de la
librería oficial.
 LiquidCrystal_I2C() – Constructor de la clase, configura el hardware.
 init() – Prepara el LCD para su uso.
 clear() – Borra todos los caracteres de la pantalla LCD.
 setCursor(col, row) – Permite mover el cursor a la posición indicada en sus parámetros.
 print() – Imprime una variable o literal en la pantalla
 scrollDisplayLeft() y scrollDisplayRight() – Recorre el contenido de la pantalla a la izquierda
o a la derecha
 backlight() y noBacklight() – Métodos para encender / apagar la iluminación de fondo
 createChar(num, data) – Crear un carácter definido por el usuario en la memoria del
controlador de pantalla
Recomendamos revisar el siguiente enlace para conocer todos los métodos de los que
dispone la librería oficial LiquidCrystal:
 Documentación de la clase LiquidCrystal (librería oficial para LCD incluida con Arduino)
Ejemplo básico para controlar LCD 16×2 por I2C
con Arduino
El siguiente programa es un ejemplo básico para comenzar a utilizar nuestra pantalla y probar
que las conexiones se encuentran correctas. Al cargarlo debemos ver letras en pantalla y
además una animación del texto moviéndose en la pantalla. Hemos comentado lo más posible
el código de manera que sea fácil de entender.
Si no se visualiza nada en la pantalla cuando se carga este programa, recomendamos
mover el potenciómetro del contraste y/o revisar las conexiones del bus I2C. En el peor
de los casos, si el adaptador I2C del que disponemos no es igual al de las fotos, puede
ser necesario cambiar los parámetros al constructor de LiquidCrystal_12C

1 /**
2 GeekFactory - "Construye tu propia tecnologia"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5
6 EJEMPLO BÁSICO PARA EL USO DEL LCD 16X2 A TRAVÉS DE I2C
7
8 ESTE PROGRAMA MUESTRA UN MENSAJE EN UNA PANTALLA DE 16X2 Y REALIZA UNA
9 ANIMACION
10 DE DESPLAZAMIENTO DE UN EXTREMO A OTRO DE LA PANTALLA.
11 */
12 #include <Wire.h>
13 #include <LiquidCrystal_I2C.h>
14
15 // Constructor de la librería de LCD 16x2
16 // Aqui se configuran los pines asignados a la pantalla del PCF8574
17 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
18
19 void setup()
20 {
21 // Indicar a la libreria que tenemos conectada una pantalla de 16x2
22 lcd.begin(16, 2);
23 // Mover el cursor a la primera posición de la pantalla (0, 0)
24 lcd.home ();
25 // Imprimir "Hola Mundo" en la primera linea
 26 lcd.print("Hola Mundo");
27 // Mover el cursor a la segunda linea (1) primera columna
28 lcd.setCursor ( 0, 1 );
29 // Imprimir otra cadena en esta posicion
30 lcd.print("GEEKFACTORY");
31 // Esperar un segundo
32 delay(1000);
33 }
34
35 void loop()
36 {
37 // EN EL CICLO PRINCIPAL SOLAMENTE RECORREMOS EL MENSAJE DE UN LADO A OTRO
38 // Variable para conteo de ciclos
39 int i;
40
41 // Desplazar la pantalla a la derecha 2 veces
42 for ( int i = 0; i < 5; i++ ) {
43 lcd.scrollDisplayRight();
44 delay (1000);
45 }
46
47 // Desplazar la pantalla a la izquierda 2 veces
48 for ( int i = 0; i < 5; i++ ) {
49 lcd.scrollDisplayLeft();
50 delay (1000);
51 }
}

Mostrar valores de sensores en LCD 16×2 por I2C

con Arduino
La librería LiquidCrystal_I2C dispone de métodos idénticos a la librería oficial de arduino, de
forma que podamos migrar los programas fácilmente, incluidos aquellos en los que se utilizan
las funciones de impresión directo en la pantalla. En el siguiente ejemplo, veremos como
mostrar el contenido de variables enteras o de tipo flotante.

1 /**
2 GeekFactory - "Construye tu propia tecnologia"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5
6 EJEMPLO BÁSICO PARA EL USO DEL LCD 16X2 A TRAVÉS DE I2C
7
8 ESTE EJEMPLO MUESTRA COMO IMPRIMIR EL VALOR DE UNA VARIABLE HACIA LA
9 PANTALLA LCD de 16x2 A TRAVÉS DE I2C. ESTO PUEDE SER UTIL PARA VISUALIZAR EL
10 VALOR LEIDO POR UN SENSOR, MOSTRAR UN CONTADOR, ETC. EN GENERAR SE PUEDE
11 UTILIZAR EN CUALQUIER INTERFAZ DE USUARIO A DESARROLLAR CON LA PANTALLA
12 LCD
13 DE 16X2.
14 */
15 #include <Wire.h>
16 #include <LiquidCrystal_I2C.h>
17
18 // Constructor de la librería de LCD 16x2
19 // Aqui se configuran los pines asignados a la pantalla del PCF8574
20 // Este constructor es para usar con el modulo I2C que se muestra en las
 21 // fotografias de nuestro sitio web. Para otros modelos, puede ser necesario
22 // cambiar los valores de acuerdo al esquemático del adaptador I2C. Los pines
23 // del arduino SIEMPRE son los correspondientes al I2C (SDA y SCL)
24
25 // Constructor sin control de backlight (retroiluminacion)
26 //LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7);
27 // Constructor con control de backlignt (retroiluminacion)
28 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
29
30 void setup()
31 {
32 // Indicar a la libreria que tenemos conectada una pantalla de 16x2
33 lcd.begin(16, 2);
34 // Mover el cursor a la primera posición de la pantalla (0, 0)
35 lcd.clear();
36 // Imprimir "Hola Mundo" en la primera linea
37 lcd.print(" GEEKFACTORY.MX ");
38 // Esperar un segundo
39 delay(1000);
40 }
41
42 void loop()
43 {
44 // Actualizar la pantalla completa cada segundo
45 lcd.clear();
46 // Imprimir encabezado
47 lcd.print(" POTENCIOMETRO ");
48
49 // Realizar la lectura analogica en A0
50 unsigned int val = analogRead(A0);
51 // Convertir a voltaje
52 float volts = (val * 5.0) / 1024.0;
53
54 // Imprimir valores en la segunda linea
55 lcd.setCursor(0, 1);
56 lcd.print(val);
57 // Imprimir el voltaje en la segunda linea, despues del valor del ADC
58 lcd.setCursor(6, 1);
59 lcd.print(volts, 1);
60
61 // Esperar un segundo antes de continuar
62 delay (1000);
}

Mostrar caracteres personalizados en LCD 16×2

por I2C
Las pantallas LCD 16×2 permiten definir hasta 8 caracteres personalizados, la librería
LiquidCrystal_I2C provee las facilidades para realizar esta tarea de manera muy sencilla.
Cada carácter se define como un grupo de 8 bytes que se envían a la memoria CGRAM. Por
ejemplo, podemos crear un icono con una carita feliz de la siguiente forma:
 Y traducido a
código en C, quedaría de la siguiente forma:

1 byte smile[8] = {
2 0b00000000,
3 0b00001010,
4 0b00001010,
5 0b00001010,
6 0b00000000,
7 0b00010001,
8 0b00001110,
9 0b00000000,
10 };

Podemos ponernos bastante creativos con esta funcionalidad del LCD y podemos obtener
resultados bastante llamativos como se puede ver en la siguiente imagen:

El siguiente programa nos muestra como dar de alta caracteres personalizados en un LCD
16×2 por I2C con Arduino
1 /**
2 GeekFactory - "Construye tu propia tecnologia"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5
6 EJEMPLO BÁSICO PARA EL USO DEL LCD 16X2 A TRAVÉS DE I2C
7
8 ESTE EJEMPLO MUESTRA COMO IMPRIMIR EL VALOR DE UNA VARIABLE HACIA LA
9 PANTALLA LCD A TRAVÉS DE I2C. ESTO PUEDE SER UTIL PARA VISUALIZAR EL
10 VALOR LEIDO POR UN SENSOR, MOSTRAR UN CONTADOR, ETC.
11 */
12 #include <Wire.h>
13 #include <LiquidCrystal_I2C.h>
14
15 // Constructor de la librería de LCD 16x2
16 // Aqui se configuran los pines asignados a la pantalla del PCF8574
17 // Este constructor es para usar con el modulo I2C que se muestra en las
18 // fotografias de nuestro sitio web. Para otros modelos, puede ser necesario
19 // cambiar los valores de acuerdo al esquemático del adaptador I2C. Los pines
20 // del arduino SIEMPRE son los correspondientes al I2C (SDA y SCL)
21
22 // Constructor sin control de backlight (retroiluminacion)
23 //LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7);
24 // Constructor con control de backlignt (retroiluminacion)
25 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
26
27 //Definicion de caracteres personalizados
28 byte smile[8] = {
29 0b00000000,
30 0b00001010,
31 0b00001010,
32 0b00001010,
33 0b00000000,
34 0b00010001,
35 0b00001110,
36 0b00000000,
37 };
38
39 byte sad[8] = {
40 0b00000000,
41 0b00001010,
42 0b00001010,
43 0b00001010,
44 0b00000000,
45 0b00001110,
46 0b00010001,
47 0b00000000,
48 };
49
50 byte body[8] = {
51 0b00001110,
52 0b00001110,
53 0b00000100,
54 0b00011111,
55 0b00000100,
56 0b00001010,
57 0b00010001,
58 0b00000000,
59 };
60
 61 byte arrowr[8] = {
62 0b00001000,
63 0b00000100,
64 0b00000010,
65 0b00011111,
66 0b00000010,
67 0b00000100,
68 0b00001000,
69 0b00000000,
70 };
71
72 byte arrowu[8] = {
73 0b00000100,
74 0b00001110,
75 0b00010101,
76 0b00000100,
77 0b00000100,
78 0b00000100,
79 0b00000100,
80 0b00000000,
81 };
82
83 byte arrowd[8] = {
84 0b00000100,
85 0b00000100,
86 0b00000100,
87 0b00000100,
88 0b00010101,
89 0b00001110,
90 0b00000100,
91 0b00000000,
92 };
93
94 byte arrowl[8] = {
95 0b00000010,
96 0b00000100,
97 0b00001000,
98 0b00011111,
99 0b00001000,
100 0b00000100,
101 0b00000010,
102 0b00000000,
103 };
104
105
106 void setup()
107 {
108 // Indicar a la libreria que tenemos conectada una pantalla de 16x2
109 lcd.begin(16, 2);
110
111 // Crear los caracteres personalizados en la pantalla
112 lcd.createChar (0, smile);
113 lcd.createChar (1, sad);
114 lcd.createChar (2, body);
115 lcd.createChar (3, arrowr);
116 lcd.createChar (4, arrowu);
117 lcd.createChar (5, arrowd);
118 lcd.createChar (6, arrowl);
119
120 // Mover el cursor a la primera posición de la pantalla (0, 0)
 121 lcd.clear();
122 // Imprimir "Hola Mundo" en la primera linea
123 lcd.print(" GEEKFACTORY.MX ");
124 // Mover cursor
125 lcd.setCursor(0, 1);
126 // Escribir bytes a la pantalla
127 // Los códigos del 0 al 7 corresponden a los caracteres personalizados
128 lcd.write((byte)0);
129 lcd.write((byte)1);
130 lcd.write((byte)2);
131 lcd.write((byte)3);
132 lcd.write((byte)4);
133 lcd.write((byte)5);
134 lcd.write((byte)6);
135 }
136
137 void loop()
138 {
139
140 }

Conclusión
 En este artículo vimos una forma más eficiente en cuanto al uso de pines para conectar una
pantalla LCD de 16 x 2 al arduino
 Revisamos las conexiones a realizar y vimos que podemos convertir la pantalla estándar a
una interfaz I2C de forma permanente.
 También aprendimos a realizar las conexiones en el protoboard, sin necesidad de soldar
definitivamente el adaptador I2C
 Descargamos e instalamos la librería correspondiente para controlar la LCD 16×2 por I2C con
Arduino
 Realizamos un ejemplo básico para mostrar texto en la pantalla
 Aprendimos a mostrar el valor de las variables en la pantalla LCD
 Mostramos como podemos crear caracteres personalizados y mostrarlos en la pantalla
6 Comments