Tradicionalmente para visualizar información con microcontroladores se han usado leds, displays de leds de 7segmentos, «tubos nixie!,LCD , pantallas OLED, etc
Hay varias ventajas para usar pantallas LCD frente a otros medios:
- Fácil visualización de datos: La pantalla LCD permite una fácil visualización de los datos generados o recibidos por el Arduino, lo que simplifica la tarea de monitoreo y análisis.
- Interfaz de usuario: Las pantallas LCD pueden ser utilizadas para crear interfaces de usuario amigables para proyectos con Arduino, lo que hace más fácil para los usuarios interactuar con el sistema.
- Versatilidad: Las pantallas LCD pueden ser utilizadas en una amplia variedad de proyectos, desde monitoreo de sensores hasta juegos y aplicaciones de tiempo real.
- Ahorro de espacio: Las pantallas LCD son más compactas y requieren menos espacio que otras opciones de visualización, lo que las hace ideales para proyectos con restricciones de espacio.
- Fácil conexión: La conexión de una pantalla LCD con una placa Arduino es generalmente sencilla y requiere pocos componentes adicionales.
- Bajo consumo de energía: Las pantallas LCD utilizan poca energía y son adecuadas para proyectos con restricciones de energía o con requisitos de larga duración.
El principio detrás de las pantallas LCD para Arduino es el uso de la tecnología de cristal líquido para desplegar información en una pantalla. Una pantalla LCD para Arduino funciona mediante la aplicación de una tensión a los cristales líquidos en la pantalla, lo que los hace inclinarse y permitir o bloquear la luz detrás de ellos. De esta manera, se pueden crear diferentes patrones de luz y oscuridad en la pantalla para formar caracteres o gráficos.
Una placa Arduino (o cualquier variante) controla la tensión aplicada a los cristales líquidos a través de un controlador LCD específico, que envía señales a los pines de la pantalla LCD. El controlador recibe y procesa los datos enviados por el Arduino y los convierte en una señal que controla la tensión aplicada a los cristales líquidos. De esta manera, se puede desplegar información en tiempo real en la pantalla LCD.
Una pantalla LCD con una placa Arduino puede ser utilizada para desplegar información o datos en tiempo real que sean generados o recibidos por el Arduino. Esto permite una visualización más clara y accesible de los datos y puede ser utilizado en una amplia variedad de proyectos, como monitoreo de sensores, interfaces de usuario, juegos, entre otros.
La placa GeekPi ( LCD1602)
Para que sirva de ejemplo, vamos a estudiar la placa GeekPi que puede comprarse en Amazon por unos 5€/unidad aqui. Esta placa utiliza el protocolo I2C para reducir la ocupación de los puertos de E / S , lo que facilita la adición al proyecto y menos cableado lo cual es fantástico ya que tradicionalmente se usaban en función del bus de 4 o 8 bits al menos 7 pines de E/S. Esta placa es comúnmente utilizado en IoT, proyectos de bricolaje, animación doméstica, construcción inteligente, proyecto de bricolaje del fabricante, etc.
Asimismo esta placa es compatible con todas las placas de desarrollo actuales, como Arduino (y todas sus variantes incluyendo ESP32, ESP8266, ECT ) , Raspberry pi, Tinkerboard, Nano pi, Banana pi, stm32, etc.
Respecto a ajustes, tan solo necesita un potenciómetro que hay detrás del lcd donde podemos ajustar la retroiluminación (color: azul) y el contraste.
La alimentación: 5v y la dirección I2C es: 0x27 y sus dimensiones son : 80 mm x 35 mm x 11 mm
En caso de conectar este lcd a una placa Arduino (o similares como ESP32, ESP8266, etc. ), las conexiones son las siguientes
Para otras placas como la Raspberry, como vemos en la imagen la conexión es similar:
Como vemos el LCD1602 usa I²C utilizando sólo dos líneas bidireccionales open-drain, Serial Data Line (SDA) y Serial Clock Line (SCL),con resistencias. Los voltajes típicos utilizados son +5 V o +3,3 V, aunque se permiten sistemas con otros voltajes. Puede funcionar siempre que sea compatible con la placa de desarrollo I2C como ya se ha comentado (las comunes Arduino, Raspberry pi, Stm32, etc.).
Este es un resumen de sus características:
- Ocupa menos puertos de E/S.
- Soporta el protocolo IIC.
- La biblioteca I2C LCD1602 es fácil de conseguir
- Con un potenciómetro para ajustar la retroiluminación y el contraste
- Retroiluminación azul
- uente de alimentación 5v
- La dirección I2C es: la nueva versión es 0x3F, la versión antigua es 0x27
Cómo conectarlo a Arduino
Conecte el módulo LCD1602 a la placa Arduino Uno como se muestra en la siguiente imagen:
I2C LCD1602 placa Arduino Uno
GND GND
VCC 5V
SDA A4 /pin 20 mega2560
SCL A5 /pin 21 mega2560
Cómo programarlo en Arduino
1.Descarga la librería LiquidCrystal_I2C
2.Abre el IDE de Arduino,Selecciona Sketch -> Include Library -> Add ZIP Library
3.Encuentra el archivo LiquidCrystal_I2C que acabas de descargar.
4.Haga clic en abrir y, a continuación, se le pedirá por «Biblioteca añadido a sus bibliotecas.
5.Marque ‘Importar bibliotecas'».
6.Abra el archivo ->Sketch->Include Library->LiquidCrystal_I2C.
7.Copia el siguiente código en el IDE de Arduino, haz click en el icono upload para subir el código a la placa de control:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27, if new version please use 0x3F instead.
void setup()
{
lcd.init(); //initialize the lcd
lcd.backlight(); //open the backlight
}
void loop()
{
lcd.setCursor(3, 0); // set the cursor to column 3, line 0
lcd.print("Hello GeeekPi"); // Print a message to the LCD
lcd.setCursor(2, 1); // set the cursor to column 2, line 1
lcd.print("hello world"); // Print a message to the LCD.
}POSICIONAR EL TEXTO
La función mylcd.lcd_display_string() imprime texto en la pantalla y también permite elegir dónde posicionarlo.
La función se usa como mylcd.lcd_display_string(«TEXTO A IMPRIMIR», FILA, COLUMNA).
El siguiente código imprime «¡Hola Mundo!» en la fila 2, columna 3:
En un LCD de 16×2, las filas están numeradas del 1 al 2, mientras que las columnas están numeradas del 0 al 15. Por lo tanto, para imprimir «¡Hola Mundo!
Así que para imprimir «¡Hola Mundo!» en la primera columna de la fila superior, usted usaría
mylcd.lcd_display_string(“Hello World!”, 1, 0)
BORRAR LA PANTALLA
La función mylcd.lcd_clear() borra la pantalla
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
mylcd.lcd_display_string("This is how you", 1)
sleep(1)
mylcd.lcd_clear()
mylcd.lcd_display_string("clear the screen", 1)
sleep(1)
mylcd.lcd_clear()
TEXTO PARPADEANTE
Podemos utilizar un simple bucle while con las funciones mylcd.lcd_display_string() y mylcd.lcd_clear() para crear un efecto de texto parpadeante continuo:
import time
import I2C_LCD_driver
mylcd = I2C_LCD_driver.lcd()
while True:
mylcd.lcd_display_string(u"Hello world!")
time.sleep(1)
mylcd.lcd_clear()
time.sleep(1)
Puede usar la función time.sleep() en la línea 7 para cambiar el tiempo (en segundos) que el texto permanece encendido.
El tiempo que el texto permanece apagado se puede cambiar en la función time.sleep() en la línea 9.
Para finalizar el programa, pulse Ctrl-C.
IMPRIMIR LA FECHA Y LA HORA
El siguiente programa imprime la fecha y hora actual en la pantalla LCD:
import I2C_LCD_driver
import time
mylcd = I2C_LCD_driver.lcd()
while True:
mylcd.lcd_display_string("Time: %s" %time.strftime("%H:%M:%S"), 1)
mylcd.lcd_display_string("Date: %s" %time.strftime("%m/%d/%Y"), 2)
IMPRIME TU DIRECCIÓN IP
Este código imprime la dirección IP de tu conexión ethernet (eth0).
Para imprimir la IP de tu conexión WiFi, cambia eth0 por wlan0 en la línea 18:
import I2C_LCD_driver
import socket
import fcntl
import struct
mylcd = I2C_LCD_driver.lcd()
def get_ip_address(ifname):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(fcntl.ioctl(
s.fileno(),
0x8915,
struct.pack('256s', ifname[:15])
)[20:24])
mylcd.lcd_display_string("IP Address:", 1)
mylcd.lcd_display_string(get_ip_address('eth0'), 2)
DESPLAZAR TEXTO DE DERECHA A IZQUIERDA CONTINUAMENTE
Este programa desplazará una cadena de texto desde el lado derecho de la pantalla LCD hacia el lado izquierdo y hará un bucle continuo:
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string
while True:
for i in range (0, len(my_long_string)):
lcd_text = my_long_string[i:(i+16)]
mylcd.lcd_display_string(lcd_text,1)
sleep(0.4)
mylcd.lcd_display_string(str_pad,1)
DESPLAZAR TEXTO DE DERECHA A IZQUIERDA UNA VEZ
El siguiente código desliza texto en la pantalla de derecha a izquierda una vez, luego se detiene y deja una pantalla limpia.
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string
for i in range (0, len(my_long_string)):
lcd_text = my_long_string[i:(i+16)]
mylcd.lcd_display_string(lcd_text,1)
sleep(0.4)
mylcd.lcd_display_string(str_pad,1)
DESPLAZAR TEXTO DE IZQUIERDA A DERECHA UNA VEZ
Este programa desliza texto en la pantalla de izquierda a derecha una vez, luego se detiene y deja los primeros 16 caracteres de la cadena de texto en la pantalla.
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
padding = " " * 16
my_long_string = "This is a string that needs to scroll"
padded_string = my_long_string + padding
for i in range (0, len(my_long_string)):
lcd_text = padded_string[((len(my_long_string)-1)-i):-i]
mylcd.lcd_display_string(lcd_text,1)
sleep(0.4)
mylcd.lcd_display_string(padding[(15+i):i], 1)
CARACTERES PERSONALIZADOS
Puede crear cualquier patrón que desee e imprimirlo en la pantalla como un carácter personalizado.
Cada carácter es una matriz de 5 x 8 píxeles.
Hasta 8 caracteres personalizados pueden ser definidos y almacenados en la memoria del LCD.
Este generador de caracteres personalizados le ayudará a crear la matriz de bits necesaria para definir los caracteres en la memoria de la LCD.
enlace: [ https://omerk.github.io/lcdchargen/ |generador de caracteres personalizados ]
IMPRIMIENDO UN CARACTER PERSONALIZADO
El siguiente código genera un caracter «<«:
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
fontdata1 = [
[ 0b00010,
0b00100,
0b01000,
0b10000,
0b01000,
0b00100,
0b00010,
0b00000 ],
]
mylcd.lcd_load_custom_chars(fontdata1)
mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)
IMPRIMIR VARIOS CARACTERES PERSONALIZADOS
Este programa imprime una flecha grande hacia la derecha (→) en la pantalla:
import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
fontdata1 = [
# char(0) - Upper-left character
[ 0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b11111,
0b11111 ],
# char(1) - Upper-middle character
[ 0b00000,
0b00000,
0b00100,
0b00110,
0b00111,
0b00111,
0b11111,
0b11111 ],
# char(2) - Upper-right character
[ 0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b10000,
0b11000 ],
# char(3) - Lower-left character
[ 0b11111,
0b11111,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000 ],
# char(4) - Lower-middle character
[ 0b11111,
0b11111,
0b00111,
0b00111,
0b00110,
0b00100,
0b00000,
0b00000 ],
# char(5) - Lower-right character
[ 0b11000,
0b10000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000 ],
]
mylcd.lcd_load_custom_chars(fontdata1)
mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)
mylcd.lcd_write_char(1)
mylcd.lcd_write_char(2)
mylcd.lcd_write(0xC0)
mylcd.lcd_write_char(3)
mylcd.lcd_write_char(4)
mylcd.lcd_write_char(5)
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.