LCD I2C PIC

¡Bienvenidos, controleros y controleras! En esta guía, aprenderás a integrar una interfaz LCD I2C con un microcontrolador PIC, utilizando el compilador CCS C PIC C Compiler. Esta técnica te permitirá reducir la cantidad de pines utilizados y simplificar el cableado de tu proyecto, lo cual es esencial cuando trabajas con microcontroladores como el PIC16F877A. Si aún no estás familiarizado con el protocolo I2C, no te preocupes, ya que también abordaremos cómo funciona y por qué es tan útil en aplicaciones con periféricos como pantallas LCD y otros dispositivos.

Antes de comenzar te hago la invitación para que veas todo nuestro CURSO DE MICROCONTROLADORES PIC.

Antes de comenzar te invito a que te unas a la comunidad de CONTROLEROS y CONTROLERAS en YouTUBE para seguir aprendiendo de estos temas de microcontroladores, control, programación, instrumentación, entre otros:

¿Qué es el Protocolo I2C y por Qué Usarlo con un PIC?

El protocolo I2C (Inter-Integrated Circuit) es una tecnología de comunicación serie que permite conectar múltiples dispositivos a un microcontrolador usando solo dos líneas: SDA (Serial Data Line) y SCL (Serial Clock Line). En lugar de ocupar varios pines para conectar periféricos, como es el caso de un LCD sin I2C, este protocolo te permite manejar múltiples dispositivos con solo dos hilos de comunicación, lo que es extremadamente útil cuando trabajas con microcontroladores como el PIC16F877A.

Funcionamiento Básico del I2C:

En un bus I2C, siempre hay un dispositivo maestro (en este caso, tu microcontrolador PIC) y uno o más dispositivos esclavos (como un LCD, un sensor de temperatura, etc.). El maestro controla el bus, enviando una señal de reloj a través de la línea SCL y transmitiendo datos a través de la línea SDA. Cada dispositivo esclavo tiene una dirección única en el bus, lo que permite al maestro comunicarse específicamente con el dispositivo deseado.

Por ejemplo, al utilizar un LCD 16×2 I2C con un PIC, el microcontrolador envía la dirección del LCD seguida de comandos específicos para mostrar caracteres en la pantalla. Este proceso es similar sin importar si estás trabajando con un PIC, un Arduino, o incluso una Raspberry Pi.

Ventajas de Usar I2C en Proyectos con PIC:

1. Ahorro de Pines: Usar I2C reduce el número de pines necesarios en el microcontrolador. Esto es crucial en proyectos donde el espacio es limitado o cuando necesitas conectar muchos dispositivos.
2. Simplicidad en el Cableado: Al utilizar solo dos líneas para la comunicación, el cableado se simplifica considerablemente, reduciendo la posibilidad de errores.
3. Facilidad para Escalar: Puedes conectar múltiples dispositivos I2C al mismo bus sin complicaciones adicionales, permitiendo la expansión fácil de tus proyectos.

Si deseas profundizar más en el protocolo I2C y cómo se aplica específicamente en microcontroladores PIC, te recomiendo leer nuestra guía completa sobre comunicación I2C con PIC.

Interfaz LCD I2C PIC

En entradas anteriores hemos aprendido como manejar un LCD usando el microcontrolar PIC16F887, y vimos que para lograr la conexión de este periférico necesitábamos ocupar 7 pines del puerto B o del Puerto D del microcontrolador como lo vemos en el siguiente esquema:

ara evitar ocupar múltiples pines del microcontrolador PIC, podemos utilizar dispositivos como el PCF8574T, un expansor de entradas y salidas digitales que se conecta mediante el protocolo I2C. Este módulo permite manejar un LCD usando solo dos pines del microcontrolador, SDA y SCL, simplificando enormemente el diseño de tu circuito. Consulta el datasheet del PCF8574T para más detalles sobre sus características técnicas.

Sin embargo, el PCF8574T puede ser encontrado incorporado en un módulo ya listo o Interfaz LCD I2C para ser usado y donde solo bastaría conectar los 2 hilos de comunicación I2C (SDA y SCL) y 2 hilos de alimentación (VCC y GND)

Está claro que para poder manipular el LCD (click aquí para ver el DATASHEET) via I2C, primero deberemos saber como funciona dicha comunicación y cuales son los comandos del PIC C Compiler – CCS C disponibles para este fin. Es por eso que te invito a que veas la entrada donde explicamos en detalle y con varios videos la Comunicación I2C con PIC.

Librería LCD I2C para PIC

En esta entrada vamos a utilizar una librería llamada I2C_FLEX_LCD, elaborada por Hugo Silva, la cual me parece funciona perfectamente y tiene la ventaja de que sus funciones son parecidas a las funciones de la librería propia del PIC C Compiler. Yo le realicé una pequeña modificación a la librería para poder colocar la dirección del modulo y el tipo de LCD directamente en la función de inicialización.

Puedes Dar CLICK EN el Siguiente Botón para Descargarla y también para que descargues los archivos de Proteus y del Ejemplo que esta al final de este post:

Antes de continuar con la implementación de la librería I2C_FLEX_LCD en tu proyecto con PIC, es importante entender bien cómo funciona el protocolo I2C, ya que te permitirá integrar fácilmente otros periféricos como sensores y módulos de memoria. Si aún no has leído nuestra guía sobre comunicación I2C con PIC, te recomiendo que lo hagas. Esta guía te dará una comprensión más profunda del protocolo y te ayudará a evitar errores comunes al trabajar con I2C en microcontroladores PIC.

Funciones de la Librería LCD I2C PIC.

Como veremos las funciones son exactamente las mismas que tiene la propia librería del LCD del PIC C Compiler:

Los pasos que se deben seguir para manejar el LCD son:
1. Incluir en el encabezado del programa la libreríá para manejar la comunicación I2C.

#use i2c(Master,Fast=100000, sda=PIN_B0, scl=PIN_B1,force_sw)

2. Incluir en el encabezado del programa el driver para manejar la interface LCD I2C.

#include <i2c_Flex_LCD.c>

3. En el programa principal se inicializa el driver. Esta parte de la librería fue modificada por mi mismo.

lcd_init(direccionI2C,filas,columnas);

direccionI2C= Es la dirección de los PINES A0, A1 y A2 del integrado( Por defecto viene en 0x4E)

filas= Número de filas del LCD

columnas= Número de columnas del LCD

La dirección puede ser cambiada directamente desde la interfaz LCD I2C como lo vemos en la siguiente imagen (Address) o si tienen el integrado es directamente de sus pines.

Basicamente, si no existe un puente de soldadura (Jumper) en A0, A1 y A2 (ese es el orden en que esta en la figura) indica un 1 lógico. A continuación se muestra las direcciones del integrado (vistas en el datasheet). Para la librería con el PIC, vamos a usar la dirección a 8 bits, si usas un Arduino, generalmente se usa la dirección a 7 bits.

4. Se usan las funciones del LCD que tiene implementadas el driver:

LCD_PUTC(c);// Muestra el caracter “C” en la próxima posición del LCD.

LCD_PUTC(«/f”);//Borra todo lo que haya en el display.

LCD_PUTC(“/n”);// Va al inicio de la segunda línea.

LCD_PUTC(“/b”); //Se mueve una posición hacia atrás.

LCD_GOTOXY(x,y); //Ubica el cursor en la posición indicada por “X” y ”Y”.

lcd_backlight_led(byte bl); //si b1=1 enciende la luz de fondo, si b1=0 apaga la luz de fondo

Ejemplo Interfaz I2C

Deben conectar la interfaz I2C LCD en los pines SDA y SCL respectivamente de el microcontrolador PIC que esten usndo. Dejo dos ejemplos a continuación:

Ahora, implementaremos la librería I2C_FLEX_LCD con el microcontrolador PIC18F4550. Este ejemplo práctico te permitirá visualizar cómo interactúa el PIC con un LCD 16×2 a través del bus I2C. Si te gustaría ver un video detallado que explique el funcionamiento de cada función de esta librería, no dudes en dejar tus comentarios. También puedes descargar los archivos de Proteus y el código fuente al final de este post para que puedas replicar este proyecto por tu cuenta.

Circuito en Proteus disponible para descarga arriba en este post:

//************************************************************************************ 
// Display LCD con Librería "i2c_Flex_LCD" Integrado (PCF8574T) 
// Código principal:
// Sergio Castaño
// https://controlautomaticoeducacion.com
//************************************************************************************ 
#include <18f4550.h>
#DEVICE ADC=10
#USE DELAY(clock=20000000,crystal)
#FUSES HS,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
#byte porta = 0xf80 // Identificador para el puerto A. 
#byte portb = 0xf81 // Identificador para el puerto B. 
#byte portc = 0xf82 // Identificador para el puerto C. 
#byte portd = 0xf83 // Identificador para el puerto D. 
#byte porte = 0xf84 // Identificador para el puerto E.
 
#use i2c(Master,Fast=100000, sda=PIN_B0, scl=PIN_B1,force_sw)  
#include "i2c_Flex_LCD.c"  

void main() {  
int i=0; 
lcd_init(0x4E,16,2);
lcd_backlight_led(ON); //Enciende la luz de Fondo
  
 while (TRUE) { 
   lcd_clear();  //Limpia el LCD

   // Envio de Strings al LCD usando la función printf
   printf(lcd_putc, "\fSuscribete a"); 
   delay_ms(1000); 
   printf(lcd_putc, "\nControl      "); 
   delay_ms(1000); 
   printf(lcd_putc, "\nAutomatico    "); 
   delay_ms(1000); 
   printf(lcd_putc, "\nEducacion     "); 
   delay_ms(1000); 

   printf(lcd_putc, "\fAprende:"); 
   delay_ms(1000); 
   printf(lcd_putc, "\n- PIC"); 
   delay_ms(1000); 
   printf(lcd_putc, "\n- Arduino"); 
   delay_ms(1000); 
   printf(lcd_putc, "\n- Control"); 
   delay_ms(1000); 

   // Limpia el LCD 
   printf(lcd_putc, "\f"); 
   delay_ms(500); 

   //Función: lcd_gotoxy()
   //Si colocan un gotoxy mayor al del LCD usado, la propia función
   //internamente coloca los límites correctos. A modo de ejemplo
   //coloquemos las esquinas correspondientes a un LCD 20x4 y la función
   //Loa adaptará si se usa un LCD 16x2

   lcd_gotoxy(3, 1);        
   printf(lcd_putc, "Numeros en");    
   lcd_gotoxy(4, 2);        
   printf(lcd_putc, "Esquinas"); 
   delay_ms(500); 
   lcd_gotoxy(1, 1);        
   printf(lcd_putc, "1"); 
   delay_ms(500); 
   lcd_gotoxy(20, 1);        
   printf(lcd_putc, "2"); 
   delay_ms(500); 
   lcd_gotoxy(20, 4);        
   printf(lcd_putc, "3"); 
   delay_ms(500); 
   lcd_gotoxy(1, 4);        
   printf(lcd_putc, "4");    
   delay_ms(2000); 
   

   // Prueba de la función de borrado Backspace
   printf(lcd_putc, "\f ¡Suscribete!\n"); 
   printf(lcd_putc,   "Activa: CAMPANA"); 
   delay_ms(2000); 

   // Ultima columna y fila  2
   //Borro la fila 2 con back space
   lcd_gotoxy(20, 2);        

   // Backspace over 2nd line. 
   for(i = 0; i < lcd_total_columns; i++) 
      { 
       printf(lcd_putc," \b\b"); 
       delay_ms(100); 
      } 

   printf(lcd_putc,   " es GRATIS!!!!!!");  
   delay_ms(3000); 

//Apaga Luz de Fondo 
         lcd_backlight_led(OFF); 
         printf(LCD_PUTC,"\fLCD BackLight\n     OFF      "); 
         delay_ms(3000); 

//Enciende Luz de Fondo
         lcd_backlight_led(ON); 
         printf(LCD_PUTC,"\fLCD BackLight\n     ON      ");  
         delay_ms(3000); 

   }    
} 

Al concluir este tutorial, deberías tener una sólida comprensión de cómo utilizar la interfaz LCD I2C con microcontroladores PIC, específicamente con el PIC18F4550. Este conocimiento no solo es aplicable a LCDs, sino también a otros periféricos que pueden ser conectados mediante I2C, como sensores y módulos de memoria. Te invito a explorar más sobre el uso de I2C con PIC en nuestro artículo dedicado, y si tienes preguntas o sugerencias, ¡deja tus comentarios abajo!

---

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.