Integrando LCD I2C con PIC C Compiler: Guía Completa

En el fascinante mundo de la electrónica y los sistemas embebidos, las pantallas LCD son componentes indispensables para visualizar datos y brindar una interfaz al usuario. Sin embargo, conectar una pantalla LCD directamente a un microcontrolador, como los populares PIC, puede consumir una cantidad considerable de pines, limitando la disponibilidad para otros periféricos. Aquí es donde el protocolo I2C (Inter-Integrated Circuit) se convierte en un verdadero salvavidas, permitiéndonos controlar un LCD con tan solo dos líneas de comunicación. Esta guía detallada te llevará de la mano a través del proceso de descarga, instalación y uso de una librería LCD I2C específicamente diseñada para el PIC C Compiler (CCS C), facilitando enormemente tus proyectos.

Desde la comprensión fundamental del protocolo I2C hasta la implementación práctica con un ejemplo de código, exploraremos cada aspecto necesario para que logres una integración exitosa. Aprenderás a liberar valiosos Pines de tu microcontrolador, simplificar el cableado y optimizar tus diseños, lo cual es crucial cuando trabajas con dispositivos como el PIC16F877A o el PIC18F4550.

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

El protocolo I2C es una tecnología de comunicación serie bidireccional que permite la conexión de múltiples dispositivos a un microcontrolador utilizando un mínimo de cableado. A diferencia de las interfaces paralelas que requieren múltiples líneas de datos y control, I2C se basa en solo dos líneas: SDA (Serial Data Line) y SCL (Serial Clock Line). Esta simplicidad en la conexión lo convierte en una opción extremadamente atractiva para proyectos donde la cantidad de pines del microcontrolador es un recurso limitado, o donde se busca reducir la complejidad del circuito.

En un bus I2C, siempre hay un dispositivo maestro y uno o más dispositivos esclavos. Tu Microcontrolador PIC actuará como el maestro, controlando el bus y generando la señal de reloj a través de la línea SCL. Los datos se transmiten de forma bidireccional a través de la línea SDA. Cada dispositivo esclavo, como un LCD I2C, un sensor de temperatura o una memoria EEPROM, posee una dirección única en el bus. Esto permite que el maestro se comunique de forma selectiva con el dispositivo deseado, enviando comandos específicos a su dirección particular.

Por ejemplo, al utilizar un LCD 16x2 I2C con un PIC, el microcontrolador envía la dirección del módulo LCD seguida de los comandos necesarios para mostrar caracteres o controlar la pantalla. Este proceso es estandarizado y similar sin importar la plataforma, ya sea un PIC, un Arduino o una Raspberry Pi, lo que demuestra la versatilidad del protocolo.

Ventajas Clave de Usar I2C en Proyectos con PIC:

• Ahorro de Pines: Esta es la ventaja más significativa. Al reducir el número de pines necesarios para la comunicación, puedes liberar puertos para otros sensores, actuadores o funciones en tu proyecto. Para un LCD, pasamos de 7 u 8 pines a solo 2.
• Simplicidad en el Cableado: Con solo dos líneas de comunicación, el cableado se vuelve mucho más limpio y ordenado, lo que disminuye las posibilidades de errores de conexión y facilita la depuración.
• Facilidad para Escalar: Puedes conectar múltiples dispositivos I2C al mismo bus simplemente asignándoles direcciones únicas. Esto permite una expansión sencilla de tus proyectos sin la necesidad de añadir más líneas de control al microcontrolador.

LCDs Estándar vs. LCDs I2C: Una Comparación Crucial

Tradicionalmente, la conexión de una pantalla LCD alfanumérica (como un 16x2 o 20x4) a un Microcontrolador PIC requería un número considerable de pines. Tomemos el ejemplo de un LCD en modo de 4 bits, que aún así necesita al menos 6 o 7 pines de control y datos (RS, EN, D4, D5, D6, D7, y a veces R/W). Si consideras un microcontrolador como el PIC16F887, esta configuración podría consumir casi un puerto completo, limitando drásticamente las opciones para otros periféricos.

Para superar esta limitación, se popularizaron los módulos de interfaz LCD I2C. Estos módulos, que a menudo incorporan un expansor de entradas y salidas digitales como el PCF8574T, se acoplan directamente a la parte trasera de la pantalla LCD. Su función principal es traducir las señales I2C de solo dos hilos (SDA y SCL) en las múltiples señales paralelas que el LCD necesita para funcionar. Esto significa que, en lugar de conectar 7 pines del PIC al LCD, solo necesitas conectar los 2 pines I2C (SDA y SCL) y 2 pines de alimentación (VCC y GND) al módulo I2C. El resto de las conexiones son internas entre el módulo PCF8574T y la pantalla LCD.

La siguiente tabla comparativa ilustra claramente las diferencias y ventajas de cada enfoque:

Descarga e Instalación de la Librería LCD I2C para PIC C Compiler

Para poder manipular el LCD I2C desde tu Microcontrolador PIC, necesitarás una Librería de software que abstraiga la complejidad del protocolo I2C y te ofrezca funciones sencillas para interactuar con la pantalla. En esta guía, utilizaremos la Librería llamada I2C_FLEX_LCD, desarrollada originalmente por Hugo Silva y con algunas modificaciones para facilitar su uso.

Para obtener esta librería y los archivos de ejemplo (incluyendo esquemas para Proteus), deberás buscar el botón de descarga en el sitio web de donde provenga esta información. Una vez que hayas descargado el archivo comprimido, extráelo. Dentro de la carpeta resultante, encontrarás los archivos necesarios, de los cuales el más importante para la programación es i2c_Flex_LCD.c.

Pasos para la Instalación:

1. Descarga: Obtén el archivo comprimido que contiene la LibreríaI2C_FLEX_LCD.c y los ejemplos asociados.
2. Extracción: Descomprime el archivo en una ubicación temporal de tu ordenador.
3. Copia de Archivos: Localiza el archivo i2c_Flex_LCD.c (y cualquier otro archivo de librería relevante que pueda venir en el paquete, aunque el principal es el .c). Deberás copiar este archivo en la carpeta de drivers de tu PIC C Compiler. La ruta típica para esta carpeta es: C:\Program Files (x86)\PICC\Drivers. Asegúrate de copiarlo en la ubicación correcta para que el compilador pueda encontrarlo cuando lo incluyas en tus proyectos.

La correcta colocación de esta Librería es fundamental para que el PIC C Compiler pueda compilar tu código sin errores. Si no se encuentra en la ubicación esperada, recibirás errores de "archivo no encontrado" durante la compilación.

Funciones de la Librería LCD I2C y Pasos de Programación

Una vez que la LibreríaI2C_FLEX_LCD está en su lugar, el proceso de programación del LCD I2C se vuelve sorprendentemente similar al de un LCD estándar, ya que las funciones principales han sido diseñadas para ser intuitivas y parecidas a las propias funciones de la librería LCD del PIC C Compiler.

Pasos Esenciales en Tu Código PIC C:

1. Incluir la Librería I2C para la Comunicación:
Antes de usar la librería del LCD, necesitas configurar los parámetros del bus I2C en tu Microcontrolador PIC. Esto se hace en el encabezado de tu programa principal:

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

Aquí:

• Master: Indica que tu PIC actuará como el dispositivo maestro en el bus I2C.
• Fast=100000: Define la velocidad del bus I2C en 100 kHz (modo rápido). Puedes ajustarla según las especificaciones de tus dispositivos.
• sda=PIN_B0, scl=PIN_B1: Especifica los Pines del PIC que serán utilizados como línea de datos (SDA) y línea de reloj (SCL) para la comunicación I2C. Asegúrate de que estos pines coincidan con tu hardware.
• force_sw: Fuerza el uso de I2C por software, útil si tu PIC no tiene un módulo I2C por hardware o si necesitas más flexibilidad.

2. Incluir el Driver de la Interfaz LCD I2C:
A continuación, debes incluir la Librería específica del LCD I2C que copiaste previamente:

#include "i2c_Flex_LCD.c"

3. Inicializar el Driver del LCD en el Programa Principal:
Dentro de la función main() de tu programa, debes inicializar el LCD. Esta función fue modificada para simplificar la configuración:

lcd_init(direccionI2C,filas,columnas);

Donde:

• direccionI2C: Es la dirección de 8 bits del módulo I2C del LCD. Por defecto, muchos módulos vienen configurados con la dirección 0x4E. Esta dirección puede ser modificada en el propio módulo LCD I2C mediante puentes de soldadura (jumpers) en los Pines A0, A1 y A2 del integrado PCF8574T. Consulta el datasheet del PCF8574T para ver las posibles combinaciones de direcciones. Es importante recordar que para PICs (y la mayoría de microcontroladores), se usa la dirección de 8 bits, mientras que en plataformas como Arduino a menudo se utiliza la dirección de 7 bits (que sería la dirección de 8 bits desplazada un bit a la derecha).
• filas: Número de filas de tu LCD (ej., 2 para un 16x2 o 4 para un 20x4).
• columnas: Número de columnas de tu LCD (ej., 16 para un 16x2 o 20 para un 20x4).

4. Uso de las Funciones Principales del LCD:
La LibreríaI2C_FLEX_LCD implementa las funciones más comunes para interactuar con la pantalla:

• LCD_PUTC(c);: Muestra el carácter 'c' en la próxima posición del cursor.
• LCD_PUTC("/f");: Borra todo el contenido de la pantalla y coloca el cursor en la posición inicial (columna 1, fila 1).
• LCD_PUTC("/n");: Mueve el cursor al inicio de la segunda línea. Útil para imprimir texto en la siguiente fila.
• LCD_PUTC("/b");: Mueve el cursor una posición hacia atrás.
• LCD_GOTOXY(x,y);: Ubica el cursor en la posición especificada por x (columna) e y (fila). Ten en cuenta que si especificas una posición fuera de los límites de tu LCD, la función internamente la ajustará a los límites correctos.
• lcd_backlight_led(byte bl);: Controla la luz de fondo del LCD. Si bl=1 (o ON), enciende la luz de fondo; si bl=0 (o OFF), la apaga.
• printf(lcd_putc, "Formato de cadena");: Permite imprimir cadenas de texto formateadas, similar a la función printf estándar de C, pero redirigiendo la salida al LCD.

Ejemplo Práctico: Interfaz LCD I2C con PIC18F4550

Para consolidar todo lo aprendido, veamos un ejemplo de código completo que utiliza la LibreríaI2C_FLEX_LCD con un Microcontrolador PIC18F4550. Este ejemplo muestra cómo inicializar el LCD, controlar la luz de fondo y mostrar diversos mensajes y formatos de texto.

Circuito de Conexión (Proteus):

Deberás conectar la interfaz I2C del LCD a los Pines SDA y SCL del Microcontrolador PIC que estés utilizando. Para el PIC18F4550, los pines SDA y SCL suelen mapearse a los Pines B0 y B1, respectivamente, si se usa la implementación de software I2C como en el ejemplo.

A continuación, se presenta el código fuente para el PIC C Compiler:

//
// 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); // Inicializa LCD de 16x2 con dirección 0x4E
 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); // Posiciona en la última columna de la segunda fila
 for(i = 0; i < 16; i++) { // Asumiendo 16 columnas para un 16x2 LCD
 printf(lcd_putc," \b\b"); // Escribe espacio y retrocede dos veces
 delay_ms(100);
 }
 printf(lcd_putc, " es GRATIS!!!!!!");
 delay_ms(3000);

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

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

Este código demuestra la facilidad de uso de la Librería. Después de la inicialización, el programa entra en un bucle infinito (while(TRUE)) donde se encarga de:

• Limpiar la pantalla con lcd_clear() o printf(lcd_putc, "\f").
• Mostrar diferentes mensajes utilizando printf(lcd_putc, ...), aprovechando los caracteres especiales como \f (clear) y \n (nueva línea).
• Utilizar lcd_gotoxy(x,y) para posicionar el cursor y escribir en ubicaciones específicas de la pantalla. El ejemplo incluso prueba los límites del LCD, demostrando la adaptabilidad de la función.
• Demostrar la función de retroceso (backspace) para borrar texto de forma dinámica.
• Controlar el encendido y apagado de la luz de fondo del LCD con lcd_backlight_led(ON/OFF).

Este ejemplo es un punto de partida excelente para tus propios proyectos, permitiéndote experimentar con las diversas funciones de la Librería y adaptarlas a tus necesidades. Puedes descargar los archivos de Proteus y el código fuente completo desde la fuente original para replicar este proyecto en tu propio entorno de desarrollo.

Preguntas Frecuentes (FAQ) sobre LCD I2C y PIC C Compiler

Para reforzar tu comprensión y resolver dudas comunes, aquí tienes algunas preguntas frecuentes:

¿Qué es la dirección I2C de un módulo LCD y cómo la modifico?

La dirección I2C es un identificador único de 8 bits que permite al microcontrolador maestro comunicarse con un esclavo específico en el bus I2C. Para los módulos LCD con PCF8574T, la dirección se configura mediante tres Pines (A0, A1, A2) que pueden ser conectados a VCC o GND mediante puentes de soldadura (jumpers). Cada combinación de estos Pines (abiertos o cerrados) establece una dirección diferente. La dirección por defecto suele ser 0x4E (o 0x27 en formato de 7 bits, común en Arduino). Si tienes problemas de comunicación, verificar y ajustar esta dirección es un paso crítico.

¿Necesito una librería diferente para cada tamaño de LCD (16x2, 20x4)?

No, la LibreríaI2C_FLEX_LCD está diseñada para ser flexible. La función lcd_init(direccionI2C,filas,columnas) te permite especificar el número de filas y columnas de tu LCD. Esto significa que la misma Librería puede ser utilizada para diferentes tamaños de pantallas alfanuméricas, siempre y cuando se inicialice correctamente con sus dimensiones.

¿Qué ocurre si los pines SDA y SCL no son PIN_B0 y PIN_B1 en mi PIC?

Si tu Microcontrolador PIC utiliza otros Pines para la comunicación I2C, simplemente debes modificar la línea #use i2c(...) en el encabezado de tu código. Por ejemplo, si usas los Pines C4 y C3, la línea sería #use i2c(Master,Fast=100000, sda=PIN_C4, scl=PIN_C3,force_sw). Es fundamental que los Pines definidos en el código coincidan con las conexiones físicas en tu circuito.

¿Puedo usar I2C para conectar otros sensores o módulos además de LCDs?

¡Absolutamente! El protocolo I2C es ampliamente utilizado para comunicar una gran variedad de dispositivos con un Microcontrolador, incluyendo sensores de temperatura y humedad (como el DHT11 o BMP280), memorias EEPROM, relojes de tiempo real (RTC), y muchos otros. Una vez que dominas la comunicación I2C con el LCD, la integración de otros periféricos I2C se vuelve mucho más sencilla, ya que el principio de comunicación es el mismo.

¿Qué significa la opción `force_sw` en la directiva `#use i2c`?

La opción `force_sw` le indica al PIC C Compiler que utilice una implementación de I2C por software, es decir, que genere las señales SDA y SCL utilizando rutinas de software en lugar de depender del módulo I2C por hardware que algunos PICs puedan tener. Esto es útil para microcontroladores que no tienen un módulo I2C dedicado, o cuando se necesita una mayor flexibilidad en la asignación de Pines o en el comportamiento del protocolo.

Conclusión

La integración de pantallas LCD I2C con microcontroladores PIC a través del PIC C Compiler es una habilidad invaluable para cualquier entusiasta o profesional de la electrónica. Al comprender el protocolo I2C y utilizar librerías optimizadas como I2C_FLEX_LCD, puedes simplificar drásticamente tus diseños, ahorrar valiosos Pines del microcontrolador y acelerar el desarrollo de tus proyectos. Esperamos que esta guía te haya proporcionado las herramientas y el conocimiento necesarios para comenzar a implementar tus propias interfaces LCD I2C de manera efectiva y eficiente. ¡El mundo de la electrónica embebida te espera!

Si quieres conocer otros artículos parecidos a Integrando LCD I2C con PIC C Compiler: Guía Completa puedes visitar la categoría Librerías.