Skip to Content

Cómo controlar un carácter I2C LCD con Arduino

Cómo controlar un carácter I2C LCD con Arduino

Este artículo incluye todo lo que necesitas saber sobre el uso de un LCD I2C de caracteres con Arduino. He incluido un diagrama de cableado y muchos códigos de ejemplo para ayudarle a empezar.

La primera parte de este artículo cubre los fundamentos de la visualización de texto y números.

En la segunda parte, entraré en más detalles sobre cómo mostrar caracteres personalizados y cómo puedes utilizar las otras funciones de la biblioteca LiquidCrystal_I2C.

Una vez que sepa cómo mostrar texto y números en la pantalla LCD, le sugiero que eche un vistazo a los artículos siguientes. En estos tutoriales, aprenderá a medir y mostrar los datos del sensor en la pantalla LCD.

Artículos recomendados

(I also have an article on How To Control A Character I2C LCD with ESP32 if you want to work with an ESP32 microcontroller instead).


Suministros

Componentes de hardware

lcdLCD I2C de 16×2 caracteres× 1Amazon
lcdLCD I2C de 20×4 caracteres (alternativa)× 1Amazon
Arduino Uno Rev 3Arduino Uno Rev3× 1Amazon
Cables de puente (macho a hembra)× 4Amazon
Cable USB tipo A/B× 1Amazon

Herramientas

Destornillador pequeñoAmazon

Software

Arduino IDEArduino IDE

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.


Fundamentos de I2C LCD

Esta guía es parte de nuestro centro de artículos sobre pantallas Arduino.

Este tipo de LCD es ideal para mostrar texto y números, de ahí el nombre de "LCD de caracteres".

El LCD I2C que estamos utilizando en este tutorial viene con un pequeño circuito adicional montado en la parte posterior del módulo.

Este módulo cuenta con un chip PCF8574 (para la comunicación I2C) y un potenciómetro para ajustar la retroiluminación LED.

La ventaja de un LCD I2C es que el cableado es muy simple. Sólo necesitas dos pines de datos para controlar el LCD.

Las pantallas LCD estándar suelen requerir unas 12 conexiones, lo que puede ser un problema si no se dispone de muchos pines GPIO.

Por suerte, también puedes comprar el circuito complementario I2C por separado en Amazon, así que también puedes actualizar fácilmente una pantalla LCD estándar.

Para un tutorial y un diagrama de cableado para LCDs de caracteres estándar, por favor vea el siguiente artículo:

Si mira de cerca la pantalla LCD, podrá ver los pequeños rectángulos que forman los caracteres individuales de la misma.

Cada rectángulo está formado por una cuadrícula de 5×8 píxeles. Más adelante en este tutorial, le mostraré cómo puede controlar los píxeles individuales para mostrar caracteres personalizados en la pantalla LCD.

Especificaciones

Las especificaciones de los LCD de 16×2, 20×4 y otros tamaños son prácticamente las mismas.

Todos ellos utilizan el mismo controlador LCD Hitachi HD44780, por lo que puedes intercambiarlos fácilmente. Sólo tendrá que cambiar las especificaciones de tamaño en su código Arduino.

Las especificaciones de una pantalla I2C típica de 16×2 se pueden encontrar en la siguiente tabla.

Especificaciones del LCD 16×2 I2C

Tensión de funcionamiento5 V
Controlador Controlador LCD Hitachi HD44780
Dirección por defecto0x27
Resolución de la pantalla2 líneas × 16 caracteres
Resolución del carácter5 × 8 píxeles
Dimensiones del módulo80 × 36 × 12 mm
Dimensiones de la zona de visión64,5 × 16,4 mm
CosteComprobar el precio

Para más información, puede consultar las hojas de datos que aparecen a continuación.

Las hojas de datos de 16×2 y 20×4 incluyen las dimensiones de la pantalla LCD y puede encontrar más información sobre el controlador LCD de Hitachi en la hoja de datos del HD44780.

El chip PCF8574 se utiliza en el módulo I2C de la parte posterior del LCD.

Cómo conectar el LCD I2C a Arduino UNO

El siguiente diagrama de cableado muestra cómo conectar la pantalla LCD I2C al Arduino.

También puedes consultar este excelente video tutorial:

El cableado de un LCD I2C es mucho más fácil que el de un LCD estándar. Sólo tienes que conectar 4 pines en lugar de 12.

I2C-LCD-con-Arduino-Diagrama de cableado-Distribución esquemática
Diagrama de cableado I2C LCD con Arduino

Las conexiones también se indican en la tabla siguiente.

Conexiones I2C LCD

LCD de caracteres I2CArduino
GNDGND
VCC5 V
SDAA4
SCLA5

Si no estás usando un Arduino Uno, los pines SDA y SCL pueden estar en una ubicación diferente.

Ten en cuenta que un Arduino Uno con la disposición R3 (pinout 1.0) también tiene las cabeceras de los pines SDA (línea de datos) y SCL (línea de reloj) cerca del pin AREF. Consulte la tabla siguiente para obtener más detalles.

JuntaSDASCL
Arduino UnoA4A5
Arduino NanoA4A5
Arduino Micro23
Arduino Mega 25602021
Arduino Leonardo23
Arduino Due2021
Ubicación de los pines SDA y SCL en diferentes placas Arduino.

Ajuste del contraste de la pantalla LCD

Después de haber cableado la pantalla LCD, tendrá que ajustar el contraste de la pantalla. En el módulo I2C, encontrarás un potenciómetro que puedes girar con un pequeño destornillador.

Enchufa el conector USB del Arduino para alimentar el LCD. Deberías ver la luz de fondo encendida.

Ahora gire el potenciómetro hasta que aparezca una (16×2 LCD) o 2 filas (20×4 LCD) de rectángulos.

Puedes ajustar el contraste más tarde si es necesario.

Una vez hecho esto, podemos empezar a programar el LCD.

Instalación de la biblioteca LiquidCrystal_I2C Arduino

En este tutorial, usaré la librería LiquidCrystal_I2C. Esta biblioteca tiene muchas funciones incorporadas que hacen que la programación del LCD sea bastante fácil.

La última versión de esta biblioteca se puede encontrar aquí en GitHub o haga clic en el botón de descarga a continuación.

Asegúrese de que tiene esta biblioteca exacta instalada y elimine cualquier otra biblioteca que tenga el mismo nombre (LiquidCrystal_I2C).

Otras bibliotecas probablemente también funcionarán, pero podrían utilizar nombres ligeramente diferentes para las distintas funciones.

La librería LiquidCrystal_I2C funciona en combinación con la librería Wire.h que permite comunicarse con dispositivos I2C. Esta librería viene preinstalada con el IDE de Arduino.

Para instalar esta biblioteca, vaya a Herramientas > Gestionar Bibliotecas (Ctrl + Shift + I en Windows) en el IDE de Arduino. El Administrador de Bibliotecas se abrirá y actualizará la lista de bibliotecas instaladas.

Instalar una librería Arduino paso 1 abrir Library Manager
Manage Libraries

Ahora busca 'liquidcrystal_i2c' y busca la biblioteca de Frank de Brabander. Selecciona la última versión y haz clic en Instalar.

Instalación de la biblioteca LiquidCrystal_I2C Arduino

La biblioteca incluye algunos ejemplos que puedes utilizar, pero tendrás que modificarlos para que se ajusten a tu configuración de hardware.

A continuación he incluido muchos códigos de ejemplo que puedes utilizar con la configuración de cableado que he mostrado anteriormente.

Primero le mostraré un código de ejemplo básico y luego le explicaré las funciones con más detalle.

¿Cómo encontrar la dirección I2C de mi LCD?

La mayoría de los LCDs I2C se envían con la dirección por defecto '0x27', pero puede ser diferente dependiendo del lote/fabricante.

Si este es el caso, tendrá que encontrar la dirección real del LCD antes de empezar a utilizarlo.

En el sitio web de Arduino, puedes encontrar un sencillo sketch de ejemplo que escanea el bus I2C en busca de dispositivos.

Si se encuentra un dispositivo, se mostrará la dirección en el monitor de serie.

/*I2C_scanner
  This sketch tests standard 7-bit addresses.
  Devices with higher bit address might not be seen properly.
*/
  
#include "Wire.h"

void setup() {
  Wire.begin();

  Serial.begin(9600);
  while (!Serial);
  Serial.println("\nI2C Scanner");
}

void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for (address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.print(address, HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error == 4) {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);
}

Si subes este sketch al Arduino y lo ejecutas, deberías ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).

Salida de monitorización en serie del buscador de direcciones I2C
Escáner de direcciones I2C Salida del monitor de serie

Anote la dirección que encuentre, la necesitará más tarde cuando programe el LCD.

Código básico de ejemplo de Arduino para LCD I2C

Puedes cargar el siguiente código de ejemplo en el Arduino utilizando el IDE de Arduino.

Para este tutorial, he utilizado esta pantalla LCD de 16×2 caracteres I2C, pero también puedes utilizar otras pantallas LCD I2C de diferentes tamaños.

Este sketch de ejemplo mostrará el clásico 'Hello World!' en la primera línea del LCD y 'LCD tutorial' en la segunda línea.

A continuación, explicaré cómo funciona el código.

/* I2C LCD with Arduino example code. More info: https://www.makerguides.com */

// Include the libraries:
// LiquidCrystal_I2C.h: https://github.com/johnrickman/LiquidCrystal_I2C
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

void setup() {
  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Print 'Hello World!' on the first line of the LCD:
  lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
  lcd.print("Hello World!"); // Print the string "Hello World!"
  lcd.setCursor(2, 1); //Set the cursor on the third column and the second row (counting starts at 0!).
  lcd.print("LCD tutorial");
}

Debería ver la siguiente salida en la pantalla LCD:

i2c lcd con arduino hello world
Output on LCD display

Cómo funciona el código

First, the required libraries are included. As mentioned earlier we need both the Wire.h and the LiquidCrystal_I2C library.

En el resto de este tutorial, cubriré más de las funciones incorporadas de esta biblioteca.

*Cuando se utiliza la última versión de la librería LiquidCrystal_I2C ya no es necesario incluir la librería wire.h en tu boceto. La otra librería importa wire.h automáticamente.

// Include the libraries:
// LiquidCrystal_I2C.h: https://github.com/johnrickman/LiquidCrystal_I2C
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

El siguiente paso es crear un objeto LCD con la clase LiquidCrystal_I2C y especificar la dirección y las dimensiones.

Para ello, utilizamos la función LiquidCrystal_I2C(address, columns, rows).

Aquí es donde tendrá que cambiar la dirección por defecto a la dirección que encontró antes si resulta ser diferente.

Si utiliza una pantalla LCD de 20×4, cambie esta línea por LiquidCrystal_I2C(0x27,20,4);

Tenga en cuenta que hemos llamado a la pantalla 'lcd'. Puedes darle un nombre diferente si lo deseas como 'menu_display'.

Tendrás que cambiar 'lcd' por el nuevo nombre en el resto del boceto.

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

En la configuración, la pantalla LCD se inicia con lcd.init() y la luz de fondo se enciende con lcd.backlight().

void setup() {
  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

En la sección de bucle del código, el cursor se sitúa en la tercera columna y la primera fila de la pantalla LCD con lcd.setCursor(2,0).

Tenga en cuenta que el conteo comienza en 0 y el primer argumento especifica la columna. Así que lcd.setCursor(2,1) coloca el cursor en la tercera columna y en la segunda fila.

A continuación se imprime la cadena "¡Hola Mundo!" con lcd.print("Hello World!"). Tenga en cuenta que debe colocar comillas (" ") alrededor del texto, ya que estamos imprimiendo un cadena de texto.

Si desea imprimir números, no es necesario poner comillas. Por ejemplo lcd.print(12345).

void loop() {
  lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
  lcd.print("Hello World!"); // Print the string "Hello World!".
  lcd.setCursor(2, 1); //Set the cursor on the third column and the second row.
  lcd.print("LCD tutorial"); // Print the string "LCD tutorial".
}

Si quieres ver un ejemplo para mostrar (cambiar) las variables en la pantalla LCD, echa un vistazo a mi tutorial para el sensor de distancia ultrasónico HC-SR04:


Otras funciones útiles de la biblioteca LiquidCrystal_I2C

El ejemplo anterior le muestra los fundamentos de la visualización de texto en el LCD. Ahora echaremos un vistazo a las otras funciones de la librería LiquidCrystal_I2C.

clear()

Borra la pantalla LCD y coloca el cursor en la esquina superior izquierda (primera fila y primera columna) de la pantalla.

Puede utilizar esta función para mostrar diferentes palabras en un bucle.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

casa()

Posiciona el cursor en la esquina superior izquierda de la pantalla. Utilice clear() si también quieres borrar la pantalla.

cursor()

Muestra el cursor de la pantalla LCD: un guión bajo (línea) en la posición del siguiente carácter a imprimir.

noCursor()

Oculta el cursor del LCD. El siguiente ejemplo crea un cursor parpadeante al final de "¡Hola Mundo!".

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Hello World!");
}

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

parpadeo()

Crea un cursor LCD estilo bloque parpadeante: un rectángulo parpadeante en la posición del siguiente carácter a imprimir.

noBlink()

Desactiva el cursor LCD de estilo bloque. El siguiente ejemplo muestra el cursor parpadeante durante 5 segundos y luego lo desactiva durante 2 segundos.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

mostrar()

Esta función enciende la pantalla LCD y muestra el texto o los cursores que se han impreso en la pantalla.

noDisplay()

Esta función desactiva cualquier texto o cursor impreso en la pantalla LCD. El texto/los datos no se borran de la memoria del LCD.

Esto significa que se mostrará de nuevo cuando la función display() se llama.

El siguiente ejemplo crea un efecto de texto parpadeante.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

escribir()

Esta función se puede utilizar para escribir un carácter en la pantalla LCD. Consulte la sección sobre la creación y visualización de caracteres personalizados más abajo para obtener más información.

scrollDisplayLeft()

Desplaza el contenido de la pantalla (texto y cursor) un espacio hacia la izquierda.

Puede utilizar esta función en la sección de bucle del código en combinación con delay(500)para crear una animación de texto en movimiento.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Hello World!");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

scrollDisplayRight()

Desplaza el contenido de la pantalla (texto y cursor) un espacio hacia la derecha.

autoscroll()

Esta función activa el desplazamiento automático de la pantalla LCD. Esto hace que cada carácter emitido en la pantalla desplace los caracteres anteriores un espacio.

Si la dirección actual del texto es de izquierda a derecha (por defecto), la pantalla se desplaza hacia la izquierda, si la dirección actual es de derecha a izquierda, la pantalla se desplaza hacia la derecha.

Esto tiene el efecto de emitir cada nuevo carácter en el mismo lugar de la pantalla LCD.

El siguiente sketch de ejemplo habilita el desplazamiento automático e imprime el carácter 0 a 9 en la posición (16,0) del LCD.

Cámbielo a (20,0) para un LCD de 20×4.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Desactiva el desplazamiento automático de la pantalla LCD.

leftToRight()

Esta función hace que el texto fluya hacia la derecha desde el cursor, como si la pantalla estuviera justificada a la izquierda (por defecto).

rightToLeft()

Esta función hace que el texto fluya hacia la izquierda desde el cursor, como si la pantalla estuviera justificada a la derecha.

¿Cómo se crean y se muestran los caracteres personalizados?

Con la función createChar() es posible crear y mostrar caracteres personalizados en la pantalla LCD.

Esto es especialmente útil si quiere mostrar un carácter que no forma parte del conjunto de caracteres ASCII estándar.

CGROM y CGRAM

Las pantallas LCD que se basan en el controlador LCD Hitachi HD44780 tienen dos tipos de memoria: CGROM y CGRAM (ROM y RAM del generador de caracteres).

CGROM genera todos los patrones de caracteres de 5 x 8 puntos a partir de los códigos de caracteres estándar de 8 bits. CGRAM puede generar patrones de caracteres definidos por el usuario.

Para pantallas de 5 x 8 puntos, CGRAM puede escribir hasta 8 caracteres personalizados y para pantallas de 5 x 10 puntos 4. Para más información, consulte la hoja de datos.

Código de ejemplo de caracteres personalizados

El siguiente ejemplo de sketch crea y muestra ocho caracteres personalizados (numerados del 0 al 7).

Puede copiar el código haciendo clic en el botón de la esquina superior derecha del campo de código.

/* Arduino example code to display custom characters on I2C character LCD. More info: www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal_I2C.h"

// Create lcd object of class LiquidCrystal_I2C:
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};

byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};

byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};

byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};

byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};

byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};

byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Initialize LCD and turn on the backlight:
  lcd.init();
  lcd.backlight();

  // Create new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clear the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

// Print all the custom characters:
void loop() {
  lcd.setCursor(0, 1);
  lcd.write(0);

  lcd.setCursor(2, 1);
  lcd.write(1);

  lcd.setCursor(4, 1);
  lcd.write(2);

  lcd.setCursor(6, 1);
  lcd.write(3);

  lcd.setCursor(8, 1);
  lcd.write(4);

  lcd.setCursor(10, 1);
  lcd.write(5);

  lcd.setCursor(12, 1);
  lcd.write(6);

  lcd.setCursor(14, 1);
  lcd.write(7);
}

Debería ver la siguiente salida en la pantalla LCD:

i2c lcd con caracteres personalizados de arduino
Display custom characters

Cómo funciona el código

Tras incluir la biblioteca y crear el objeto LCD, se definen las matrices de caracteres personalizadas.

Cada matriz consta de 8 bytes (sólo se consideran 5 bits).

Hay 1 byte por cada fila de la matriz de 5 x 8 leds. En este ejemplo, se crean 8 caracteres personalizados.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

Al observar detenidamente la matriz, verá lo siguiente. Cada fila consta de 5 números que corresponden a los 5 píxeles de un carácter de 5 x 8 puntos.

Un 0 significa píxel apagado y un 1 significa píxel encendido. El prefijo 'B' es el formateador binario específico de Arduino.

Es posible editar cada fila a mano, pero recomiendo utilizar esta herramienta visual en GitHub.

Esta aplicación crea automáticamente la matriz de caracteres y puedes hacer clic en los píxeles para activarlos o desactivarlos.

En la configuración, los caracteres personalizados se crean con lcd.createChar(num, data).

El primer argumento de esta función es el número del carácter personalizado (0-7) y el segundo argumento es la matriz de caracteres que hemos creado.

  // Create new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

En el bucle, todos los caracteres se muestran con lcd.write(). Como argumento, utilizamos el número del carácter personalizado que queremos mostrar.

  lcd.setCursor(0, 1);
  lcd.write(0);

Conclusión

En este artículo, le he mostrado cómo utilizar una pantalla LCD I2C de caracteres con Arduino.

Espero que te haya resultado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas!

Me encantaría saber qué proyectos planeas construir (o ya has construido) con estos LCDs. Si tienes alguna pregunta, sugerencia o si crees que faltan cosas en este tutorial, por favor deja un comentario abajo.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.

Licencia Creative Commons

Sampath

Tuesday 6th of June 2023

How I can back spaces character one by one

Marty

Miércoles 23 de noviembre de 2022

Gracias por la guía. Tengo un complejo sketch de Mega que automatiza la marcha de dos maquetas de trenes según un horario (utilizando un escudo de motor con una fuente de alimentación independiente). Estoy usando una pantalla lcd de 20x4 para dar mensajes de estado. También hay otras dos pantallas OLED I2C en una dirección diferente que muestran la información de la salida del tren. El sketch funciona bien durante varios minutos y varios ciclos de tren, entonces la pantalla LCD se queda en blanco. Necesito que funcione durante horas. La luz de fondo de la pantalla LCD permanece encendida. El sketch sigue funcionando y las pantallas OLED se actualizan. Los OLEDs y el LCD se alimentan con una fuente regulada de 5V separada con una tierra común al Mega. El Mega se alimenta con una fuente regulada de 9V. Las líneas SCL y SDA están en los buses soldados de la protoboard para los tres dispositivos I2C. Las longitudes de los cables son cortas, menos de un pie. No estoy usando ninguna resistencia pull-up en los buses SCL o SDA. ¿Alguna sugerencia? Una fuente dice que intente un lcd.init() cada minuto más o menos.

reza

Lunes 29 de agosto de 2022

Gracias, es una guía increíble para arduino. fácil de entender, funcionó completamente y es útil, los amo.

bender22

Jueves 31 de marzo de 2022

Me puse a pensar en este problema durante la noche y sólo pude llegar a la conclusión de que debe ser un problema del controlador. Mi problema parece ser que he seguido el código donde dice: // Incluir las librerías: // LiquidCrystal_I2C.h: https://github.com/johnrickman/LiquidCrystal_I2C El código de johnrickman no ha funcionado como he descrito a continuación. Pero antes en el escrito dijiste que "buscara la librería de Frank de Brabander". Esto ya no existe como una biblioteca, así que hice una búsqueda en Google y encontré a Frank en https://www.arduinolibraries.info/libraries/liquid-crystal-i2-c He descargado e instalado el archivo LiquidCrystal_I2C-1.1.2.zip. Ahora todo está bien. Muestro "Hello World" y "LCD tutorial". Nuevamente, gracias por tu escrito. Salvo por las dos librerías diferentes tienes un sitio excelente. Saludos cordiales

bender22

Miércoles 30 de marzo de 2022

En primer lugar me gustaría agradecerle su página tan clara e informativa sobre el uso del módulo I2C LCD. He probado todos los ejemplos y "más o menos" han funcionado, pero tengo un problema. Cuando hago un lcd.print, el LCD sólo muestra la primera letra de la palabra. ej. "Hola" sólo muestra una 'H'. El 'display custom characters' funciona muy bien con una cadena de gráficos como debería, sin embargo, como dije, al imprimir "Custom" sólo mostrará una 'C'. Cuando modifiqué su programa para imprimir "Custom", especificando la posición de impresión en la primera línea seguida de los gráficos en la segunda línea, esto funcionó bien. Entonces, si especifico la posición de impresión, se imprime, de lo contrario sólo imprime el primer carácter de la palabra. lcd.setCursor(0, 0); lcd.print("C"); lcd.setCursor(2, 0); lcd.print("u"); lcd.setCursor(4, 0); lcd.print("s"); lcd.setCursor(6, 0); lcd.print("t"); lcd.setCursor(8, 0); lcd.print("o"); ¿Crees que puedes darme una pista sobre cuál puede ser el problema? He cambiado la pantalla LCD así como el módulo I2C. Gracias de antemano. Saludos cordiales