hogar › Consejos › Trabajando con pantalla gráfica 1602 en arduino. LCD WH1602B de Winstar. Control de pantalla LCD a través del bus I2C

Trabajando con pantalla gráfica 1602 en arduino. LCD WH1602B de Winstar. Control de pantalla LCD a través del bus I2C

Ha llegado Arduino Nano, llegó un kit que contenía una placa de pruebas y una pantalla LCD. La pantalla en el tablero dice - 1602A, debajo - QAPASS. Comencé a esculpir el primer dispositivo y, por supuesto, quería mostrar información en la pantalla y no parpadear los LED.

Google me ayudó, me dijo que se trata de una visualización de caracteres; Si no lo distorsiona, lo más probable es que haya caracteres ASCII disponibles: números, latín y algunos de los caracteres básicos.

Los siguientes materiales ayudaron a iniciar la pantalla: Manejar una pantalla LCD de tipo caracteres desde un puerto de impresora de PC; Cómo conectar Arduino con una pantalla LCD de caracteres; PDF de control del motor servocontrolador Pwm.

La pantalla es bastante común y ya se han inventado escudos para ella: hay opciones con SPI, como, y/o con I2C, e Internet está lleno de recetas para estos casos. Pero sólo tenía la pantalla original de 16x2 y el Arduino al que quería conectarlo.

La pantalla tiene un modo de operación y transmisión de datos en nibbles, de 4 bits cada uno, mientras que los bits de orden inferior del bus no se utilizan. La conexión de solo la mitad del bus de datos se describe en muchos lugares y no descubrí cómo conectar la pantalla y trabajar con ella en 8 líneas. Estoy bastante contento con cómo funciona.

Buena descripción de las pantallas. de este tipo Lo encontré aquí: http://greathard.ucoz.com/44780_rus.pdf. Y aquí (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) hay un ejemplo de cómo especificar un generador de caracteres.

Conexión

Mi pantalla vino con contactos sin soldar. Desde el principio quise soldar el cable, cortar 16 hilos con duponts y limpiarlos. Y luego busqué en la ballena y encontré un peine DuPont para soldar al tablero. A partir de ahí rompí 16 contactos y los soldé.
Mi pantalla se veía así (antes de soldar los contactos):

Primero conecté el pin 15 (A) a +5V, 16 (K) a tierra y me aseguré de que la luz de fondo funcionara. En general lo correcto es conectar el cátodo a tierra mediante una resistencia de 220 Ohm, que es lo que hice entonces.

Luego conecté tierra (1) y alimentación (2). Arduino se puede alimentar desde USB, desde un voltaje estabilizado de 5V y desde uno no estabilizado de 6-12V, se selecciona automáticamente el voltaje más alto. Ahora el Arduino se alimenta desde USB y me preguntaba dónde conseguir 5 voltios. Resultó que hay 5V en el pin Arduino, donde se conectan 5V estabilizados externos. O mejor dicho, resultó ser 4,7V, pero para mí fue suficiente.

Después de conectar la alimentación, si todo está bien, la fila superior se ilumina con rectángulos sólidos de familiaridad.

Luego conectamos el potenciómetro de contraste (pin 3 V0). Tiramos uno de los terminales extremos del potenciómetro al suelo, el segundo a +5V, el del medio al pin 3 del display. Se recomienda un potenciómetro de 10K. Tenía 50K de ballena, lo usé primero. El ajuste se realizó sólo en un borde, fue necesario captar muy sutilmente el contraste deseado. Luego encontré uno similar a 5K en otra ballena y lo instalé. El ajuste se extendía desde un borde hasta media vuelta. Aparentemente, puedes llevar un potenciómetro aún más pequeño. Probablemente se recomiende 10K para que el circuito consuma menos. Sí, tuve que soldar un poco, soldé cables con duponts a las terminales de los potenciómetros.

Bosquejo de prueba

Tomamos el boceto de prueba de los ejemplos de Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", solo necesitamos cambiar los contactos a los nuestros - LiquidCrystal lcd( 7, 6, 5, 4, 3, 2);

En principio, este boceto también contiene una descripción de qué conectar y dónde. Puedes conectarlo como se indica allí, entonces no necesitas cambiar nada en absoluto.

// incluye el código de la biblioteca: #include // inicializa la biblioteca con los números de los pines de la interfaz LiquidCrystal lcd(7, 6, 5, 4, 3, 2); void setup() ( // configura el número de columnas y filas de la pantalla LCD: lcd.begin(16, 2); // imprime un mensaje en la pantalla LCD. lcd.print("¡hola, mundo!"); ) void loop() ( // establece el cursor en la columna 0, línea 1 // (nota: la línea 1 es la segunda fila, ya que el conteo comienza con 0): lcd.setCursor(0, 1); // imprime el número de segundos desde el reinicio: lcd.print(millis() / 1000); )

Resulta algo como esto:

Por cierto, la pantalla que llegó a mis manos no funciona sin retroiluminación. Quiero decir, funciona, pero casi no se ve nada.

Contactos de pantalla 1602A

# contacto	Nombre	Como conectar
1	VSS	Tierra
2	VDD	+5V
3	V0	Contraste - al terminal medio del potenciómetro
4	RS (selección de registro)	D7Arduino
5	R/W (lectura o escritura)	Tierra
6	E (Habilitar señal)	D6Arduino
7-14	D0-D7	D0-D3 - no conectado; D4-D7 - conectado a los pines D5-D2 de Arduino
15	A	Ánodo de retroiluminación, conectado a +5V
16	k	Cátodo de retroiluminación, conectado a tierra mediante una resistencia de 220 ohmios.

El artículo habla sobre cómo conectar correctamente una pantalla LCD a Arduino, se cubre todo lo que necesita saber sobre cómo conectar LCD 1602 y LCD i2c.

Las pantallas LCD de 1602 tamaños, creadas sobre la base del controlador HD44780, siguen siendo hoy en día una de las más asequibles, sencillas y demandadas para desarrollar cualquier tipo de dispositivo electrónico.

No es de extrañar que se puedan ver tanto en unidades simples montadas literalmente sobre la rodilla como en unidades industriales más serias, por ejemplo, máquinas de café. Es con esta pantalla que se ensamblan los módulos y protectores más populares relacionados con Arduino, por ejemplo el módulo LCD I2C y el protector de teclado LCD.

En los siguientes pasos te contamos detalladamente con imágenes cómo conectar el LCD al Arduino y mostrar la información necesaria en el display.

Paso 2. LCD 1602 para Arduino

Las pantallas 1602 vienen en dos diseños diferentes:

retroiluminación amarilla con letras negras
o (esto sucede con mucha más frecuencia) retroiluminación azul con luces blancas.

El tamaño de las pantallas del controlador HD44780 varía mucho, pero se controlan de la misma manera. Las dimensiones más habituales son 16 por 02 (es decir, 16 caracteres en dos líneas) o 20 por 04. Los propios caracteres tienen una resolución de 5 por 8 píxeles.

La mayoría de las pantallas no admiten cirílico (a excepción de las pantallas con la marca CTK). Pero este problema tiene solución parcial y el artículo describe con más detalle cómo hacerlo.

La pantalla tiene un conector de 16 PIN para su conexión. Los pines están marcados en la parte posterior del tablero, es el siguiente:

1 (VSS) – fuente de alimentación negativa para el controlador.
2 (VDD) – fuente de alimentación positiva para el controlador.
3 (VO): configuración de control de contraste.
4 (RS) – selección de registro.
5 (R/W) – lectura y escritura, en particular, escritura cuando está conectado a tierra.
6 (E) – activación (habilitar).
7–10 (DB0-DB3): bits de orden inferior de la interfaz de ocho bits.
11–14 (DB4-DB7): bits más significativos de la interfaz
15 (A) – ánodo positivo para alimentación de retroiluminación.
16 (K) – cátodo negativo para fuente de alimentación de retroiluminación.

Paso 3. Conecte la pantalla LCD

Antes de conectar la pantalla y transferirle información, vale la pena comprobar su funcionalidad. Primero, aplique voltaje al controlador VSS y VDD, encienda la luz de fondo (A, K) y luego ajuste el contraste.

Para tales ajustes es adecuado un potenciómetro de 10 kOhm, su forma no importa. Se suministran +5V y GND a las patas exteriores, y la pata del centro está conectada al pin VO.

Cuando se suministra energía al circuito, es necesario lograr el contraste necesario; si se ajusta incorrectamente, la imagen en la pantalla no será visible. Para ajustar el contraste es necesario “jugar” con el potenciómetro. Cuando el circuito está ensamblado correctamente y el contraste está ajustado correctamente, la línea superior de la pantalla debe llenarse de rectángulos.

Para que la pantalla funcione, se utiliza una biblioteca especial integrada en el entorno IDE de Arduino, LiquidCrystal.h, sobre la que escribiré a continuación. Puede funcionar en modo de 8 y 4 bits. En la primera opción, solo se utilizan los bits más significativos y menos significativos ( BB0-DB7), en el segundo – sólo los más jóvenes ( BB4-DB7).

Pero usar el modo de 8 bits en esta pantalla es una decisión equivocada; casi no hay ventaja en velocidad, ya que su frecuencia de actualización es siempre inferior a 10 veces por segundo. Para mostrar texto, debe conectar los pines DB7, DB6, DB5, DB4, E y RS a los pines del controlador. Se pueden conectar a cualquier pin Arduino, lo principal es establecer la secuencia correcta en el código.

Si el símbolo requerido aún no está en la memoria del controlador, puede definirlo manualmente (hasta siete símbolos en total). La celda en las pantallas consideradas tiene una extensión de cinco por ocho píxeles. La tarea de crear un símbolo es escribir una máscara de bits y colocar unos en los lugares donde los puntos deberían iluminarse y ceros donde no deberían iluminarse. El diagrama de conexión comentado anteriormente no siempre es bueno, ya que en el Arduino se utilizan al menos seis salidas digitales.

Paso 4. Esquema de derivación

Exploremos una opción para solucionar este problema y arreglárnoslas con solo dos. Necesitamos un módulo convertidor adicional de LCD a IIC/I2C. En las imágenes a continuación se puede ver cómo se suelda a la pantalla y se conecta al Arduino.

Pero esta opción de conexión sólo funciona con una biblioteca especial, LiquidCrystal_I2C1602V1, que, sin embargo, es fácil de encontrar e instalar en Internet, tras lo cual podrás utilizarla sin problemas.

Paso 4: Biblioteca LiquidCrystal.h

La biblioteca LiquidCrystal.h se puede descargar desde la sección Bibliotecas de nuestro sitio web en esta página o desde el recurso oficial arduino.cc. Pero también puedes descargar desde los siguientes enlaces:

Paso 5. Bosquejo (código del programa)

Una vez que haya descargado el archivo, reemplace la carpeta LiquidCrystal en la carpeta de bibliotecas de su directorio de instalación de Arduino.

Puedes ver un boceto de muestra en:

Archivo -> Ejemplos -> LiquidCrystal -> HelloWorld_SPI

O, si tienes un menú en inglés:

Archivo -> Ejemplos -> LiquidCrystal -> HelloWorld_SPI

Esto concluye nuestra próxima lección. ¡Te deseamos proyectos de calidad!

pantalla LCD– un invitado frecuente en proyectos Arduino. Pero en circuitos complejos podemos tener el problema de la falta de puertos Arduino por la necesidad de conectar un blindaje que tiene muchísimos pines. La solución a esta situación podría ser I2C/CII un adaptador que conecta un escudo Arduino 1602 casi estándar a placas Uno, Nano o Mega usando solo 4 pines. En este artículo veremos cómo se puede conectar una pantalla LCD con una interfaz I2C, qué bibliotecas puede usar, escribiremos un breve boceto de ejemplo y veremos errores comunes.

Pantalla de cristal líquido LCD 1602 es buena elección para generar cadenas de caracteres en varios proyectos. Es económico, hay varias modificaciones con diferentes colores de retroiluminación, puede descargar fácilmente bibliotecas listas para usar para bocetos de Arduino. Pero la principal desventaja de esta pantalla es el hecho de que tiene 16 pines digitales, de los cuales se requieren al menos 6. Por lo tanto, usar esta pantalla LCD sin i2c agrega serias restricciones para las placas Arduino Uno o Nano. Si no hay suficientes contactos, tendrá que comprar una placa Arduino Mega o guardar contactos, incluso conectando la pantalla a través de i2c.

Breve descripción de los pines del LCD 1602

Echemos un vistazo más de cerca a los pines del LCD1602:

Cada uno de los pines tiene su propio propósito:

Tierra GND;
Fuente de alimentación 5 V;
Configuración del contraste del monitor;
Comando, datos;
Escritura y lectura de datos;
Permitir;

7-14. Líneas de datos;

Más luz de fondo;
Menos la luz de fondo.

Especificaciones de la pantalla:

Tipo de visualización de caracteres, es posible cargar símbolos;
Luces led;
Controlador HD44780;
Tensión de alimentación 5V;
Formato de 16x2 caracteres;
Rango de temperatura de funcionamiento de -20 °C a +70 °C, rango de temperatura de almacenamiento de -30 °C a +80 °C;
Ángulo de visión 180 grados.

Diagrama de conexión de LCD a placa Arduino sin i2C

El diagrama estándar para conectar un monitor directamente a un microcontrolador Arduino sin I2C es el siguiente.

Debido a la gran cantidad de contactos conectados, es posible que no haya suficiente espacio para conectar los elementos necesarios. El uso de I2C reduce la cantidad de cables a 4 y los pines ocupados a 2.

Dónde comprar pantallas LCD y escudos para Arduino

La pantalla LCD 1602 (y la versión 2004) es bastante popular, por lo que puede encontrarla fácilmente tanto en tiendas en línea nacionales como en sitios extranjeros. Aquí hay algunos enlaces a las opciones más disponibles:

Módulo de pantalla azul LCD1602+I2C, compatible con Arduino	Una pantalla LCD1602 simple (retroiluminación verde) más barata que 80 rublos	Gran pantalla LCD2004 con I2C HD44780 para Arduino (retroiluminación azul y verde)
Pantalla 1602 con adaptador IIC y retroiluminación azul	Otra versión de LCD1602 con un módulo I2C soldado	Módulo adaptador Port IIC/I2C/TWI/SPI para escudo 1602, compatible con Arduino
¡Pantalla retroiluminada RGB! LCD 16×2 + teclado +Buzzer Shield para Arduino	Escudo para Arduino con botones y pantalla LCD1602 LCD 1602	Display LCD para impresora 3D (Smart Controller for RAMPS 1.4, Text LCD 20×4), módulo lector de tarjetas SD y MicroSD

Descripción del protocolo I2C

Antes de hablar sobre la conexión de la pantalla a Arduino mediante un adaptador i2c, hablemos brevemente sobre el protocolo i2C en sí.

I2C/CII(Circuito Interintegrado) es un protocolo creado originalmente para la comunicación circuitos integrados adentro dispositivo electronico. El desarrollo pertenece a Philips. El protocolo i2c se basa en el uso de un bus de 8 bits, necesario para comunicar bloques en la electrónica de control, y un sistema de direccionamiento, gracias al cual es posible comunicarse a través de los mismos cables con varios dispositivos. Simplemente transferimos datos a uno u otro dispositivo agregando el identificador del elemento deseado a los paquetes de datos.

lo mas circuito simple I2C puede contener un dispositivo maestro (normalmente un microcontrolador Arduino) y varios esclavos (por ejemplo, una pantalla LCD). Cada dispositivo tiene una dirección en el rango de 7 a 127. No debe haber dos dispositivos con la misma dirección en el mismo circuito.

La placa Arduino admite i2c en hardware. Puede utilizar los pines A4 y A5 para conectar dispositivos que utilizan este protocolo.

El funcionamiento I2C tiene varias ventajas:

La operación requiere solo 2 líneas: SDA (línea de datos) y SCL (línea de sincronización).
Conexión de una gran cantidad de dispositivos líderes.
Tiempo de desarrollo reducido.
Sólo se requiere un microcontrolador para controlar todo el conjunto de dispositivos.
El número posible de microcircuitos conectados a un bus está limitado únicamente por la capacidad máxima.
Alto grado de seguridad de los datos gracias a un filtro especial de supresión de sobretensiones integrado en los circuitos.
Un procedimiento simple para diagnosticar fallas emergentes y depurar fallas rápidamente.
El bus ya está integrado en el propio Arduino, por lo que no es necesario desarrollar una interfaz de bus adicional.

Defectos:

Hay un límite capacitivo en la línea: 400 pF.
Es difícil programar un controlador I2C si hay varios dispositivos diferentes en el bus.
Con una gran cantidad de dispositivos, resulta difícil aislar una falla si uno de ellos baja por error.

Módulo i2c para LCD 1602 Arduino

La forma más rápida y cómoda de utilizar una pantalla i2c en Arduino es comprar una pantalla ya preparada con soporte de protocolo integrado. Pero no hay muchas de estas pantallas y no son baratas. Pero ya se han producido una gran cantidad de pantallas estándar diferentes. Por lo tanto, la opción más asequible y popular hoy en día es comprar y utilizar un módulo I2C independiente: un adaptador que se parece a esto:

En un lado del módulo vemos los pines i2c: tierra, alimentación y 2 para transferencia de datos. En el otro adaptador vemos conectores de alimentación externos. Y, por supuesto, la placa tiene muchos pines con los que se suelda el módulo a los pines de pantalla estándar.

Las salidas i2c se utilizan para conectarse a la placa Arduino. Si es necesario, conectamos alimentación externa para retroiluminación. Con el trimmer incorporado podremos establecer valores de contraste personalizados J

En el mercado se pueden encontrar módulos LCD 1602 con adaptadores ya soldados, su uso se simplifica al máximo. Si compró un adaptador por separado, primero deberá soldarlo al módulo.

Conexión de la pantalla LCD a Arduino a través de I2C

Para conectarse, necesita la placa Arduino, una pantalla, una placa de pruebas, cables de conexión y un potenciómetro.

Si está utilizando un adaptador i2c especial independiente, primero debe soldarlo al módulo de pantalla. Es difícil cometer un error allí, puedes seguir este esquema.

Un monitor LCD con soporte i2c se conecta a la placa mediante cuatro cables: dos cables para datos y dos cables para alimentación.

El pin GND se conecta a GND en la placa.
El pin VCC está a 5V.
SCL se conecta al pin A5.
SDA está conectado al pin A.

¡Y eso es todo! Sin redes de cables en las que es muy fácil enredarse. Al mismo tiempo, podemos simplemente confiar toda la complejidad de implementar el protocolo i2C a las bibliotecas.

Bibliotecas para trabajar con la pantalla LCD i2c

Para interactuar con Arduino y LCD 1602 a través del bus I2C, necesitará al menos dos bibliotecas:

La biblioteca Wire.h para trabajar con I2C ya está incluida en el estándar programa arduino IDE.
La biblioteca LiquidCrystal_I2C.h, que incluye una amplia variedad de comandos para controlar el monitor a través del bus I2C y le permite hacer el boceto más simple y corto. Debe instalar adicionalmente la biblioteca. Después de conectar la pantalla, debe instalar adicionalmente la biblioteca LiquidCrystal_I2C.h.

Después de conectar todas las bibliotecas necesarias al boceto, creamos un objeto y podemos usar todas sus funciones. Para realizar pruebas, carguemos el siguiente boceto de ejemplo estándar.

#incluir #incluir // Incluyendo la biblioteca //#include // Conectando una biblioteca alternativa LiquidCrystal_I2C lcd(0x27,16,2); // Especifique la dirección I2C (el valor más común), así como los parámetros de la pantalla (en el caso de LCD 1602 - 2 líneas de 16 caracteres cada una //LiquidCrystal_PCF8574 lcd(0x27); // Opción para la configuración nula de la biblioteca PCF8574( ) ( lcd.init (); // Inicializando la pantalla lcd.backlight(); // Conectando la retroiluminación lcd.setCursor(0,0); // Estableciendo el cursor al comienzo de la primera línea lcd.print(" Hola"); // Escribiendo texto en la primera línea lcd.setCursor(0,1); // Establece el cursor al principio de la segunda línea lcd.print("ArduinoMaster"); // Escribe texto en la segunda línea ) bucle vacío() ( )

Descripción de funciones y métodos de la biblioteca LiquidCrystal_I2C:

home() y clear(): la primera función le permite devolver el cursor al principio de la pantalla, la segunda hace lo mismo, pero al mismo tiempo elimina todo lo que estaba antes en el monitor.
write(ch): le permite imprimir un solo carácter ch en la pantalla.
cursor() y noCursor(): muestra/oculta el cursor en la pantalla.
Blink() y noBlink(): el cursor parpadea/no parpadea (si su visualización estaba habilitada antes).
display() y noDisplay(): le permite conectar/deshabilitar la pantalla.
scrollDisplayLeft() y scrollDisplayRight(): desplaza la pantalla un carácter hacia la izquierda o hacia la derecha.
autoscroll() y noAutoscroll(): le permiten habilitar/deshabilitar el modo de desplazamiento automático. En este modo, cada nuevo carácter se escribe en el mismo lugar, desplazando lo escrito anteriormente en la pantalla.
leftToRight() y rightToLeft(): configura la dirección del texto mostrado: de izquierda a derecha o de derecha a izquierda.
createChar(ch, bitmap): crea un carácter con código ch (0 – 7), utilizando una matriz de mapas de bits para crear puntos en blanco y negro.

Biblioteca alternativa para trabajar con la pantalla i2c

En algunos casos, pueden producirse errores al utilizar la biblioteca especificada con dispositivos equipados con controladores PCF8574. En este caso, se puede sugerir la biblioteca LiquidCrystal_PCF8574.h como alternativa. Extiende LiquidCrystal_I2C, por lo que no debería haber problemas al usarlo.

Problemas al conectar la pantalla lcd i2c

Si después de cargar el boceto no ves ningún mensaje en la pantalla, prueba los siguientes pasos.

Primero, puede aumentar o disminuir el contraste del monitor. A menudo, los caracteres simplemente no son visibles debido al modo de contraste y retroiluminación.

Si esto no ayuda, verifique si los contactos están conectados correctamente y si la alimentación de la luz de fondo está conectada. Si utilizó un adaptador i2c separado, verifique nuevamente la calidad de la soldadura de los contactos.

Otra razón común por la que falta texto en la pantalla puede ser una dirección i2c incorrecta. Primero intente cambiar la dirección del dispositivo en el boceto de 0x27 0x20 o 0x3F. Diferentes fabricantes pueden tener diferentes direcciones predeterminadas programadas. Si esto no ayuda, puede ejecutar el boceto del escáner i2c, que escanea todos los dispositivos conectados y determina su dirección mediante fuerza bruta. Un ejemplo de un boceto de escáner i2c.

Si la pantalla sigue sin funcionar, prueba a desoldar el adaptador y conectar el LCD como de costumbre.

Conclusión

En este artículo, analizamos los principales problemas del uso de una pantalla LCD en proyectos complejos de Arduino, cuando necesitamos guardar pines libres en la placa. Un adaptador i2c sencillo y económico le permitirá conectar una pantalla LCD 1602, ocupando sólo 2 pines analógicos. En muchas situaciones esto puede ser muy importante. El precio de la comodidad es la necesidad de utilizar un módulo adicional: un convertidor y una biblioteca. En nuestra opinión, este no es un precio alto a pagar por la comodidad y recomendamos encarecidamente utilizar esta función en proyectos.

¿Qué es parte integral de una gran cantidad de dispositivos electrónicos? Por supuesto, medios de indicación y salida gráfica de datos. Siempre es más cómodo y agradable para el usuario cuando el resultado de la “caja inteligente” se puede ver visualmente. Por lo tanto, hoy conectaremos una pantalla al STM32 para mostrar texto y números. El héroe de nuestros experimentos será una pantalla bastante popular de Winstar. Por cierto, apareció una aclaración importante en los comentarios de que la metodología es básicamente la misma para todas las pantallas según HD44780. Gracias a JekaKey por la importante incorporación)

Primero, la pantalla debe estar conectada al controlador. Descargue la hoja de datos y busque el pinout del WH1602. Mira aquí:

Como tú sabes, pantalla WH1602 tiene 16 pines. Veamos cada uno por separado...

Los pines Vss, Vdd y K deben estar conectados a tierra y a alimentación, es decir, exactamente como se indica en la tabla, no hay sorpresas ni nada que comentar)

El pin número 3 se utiliza para ajustar el contraste: si aplicamos +5V allí, no veremos absolutamente nada, y si cortocircuitamos el pin a tierra, admiraremos dos filas de cuadrados negros 😉 Naturalmente, esto no nos conviene , por lo que necesitamos colgar allí un potenciómetro (resistencia) con resistencia variable) para ajustar el contraste. La mejor visibilidad de los caracteres la proporciona un voltaje de 0,5-0,7 V en este pin de visualización.

El pin RS ya es un pin que nosotros mismos controlaremos mediante un microcontrolador. Un nivel de voltaje bajo (0) en este pin significa que ahora seguirá un comando, un nivel alto (1) significa que ahora habrá datos para escribir en la memoria de la pantalla.

Pin R/W: aquí está claro, o leemos los datos (mostramos el indicador de ocupado, por ejemplo), en este caso hay 1 en este pin, o escribimos el comando/datos en la pantalla, entonces tenemos 0 aquí.

DB7 – DB0 – bus de datos, y eso lo dice todo)

El pin E es la llamada señal de habilitación. Para esto es necesario. Para trabajar con la pantalla (registrar datos o emitir un comando), debemos enviar un pulso positivo a este pin. Es decir, el procedimiento quedará así:

En los pines RS, R/W, DB7 - DB0 - las señales necesarias correspondientes a nuestro comando.
Suministramos uno al pin E.
Zhdems (según la hoja de datos – al menos 150 ns)
Aplicamos un nivel bajo (0) al pin E.

Debe colocar 4,2 V en la pata A/Vee para alimentar la luz de fondo de la pantalla.

Así se produce la comunicación con el display WH1602.

Descubrimos cómo conectar el WH1602, pero antes de pasar al ejemplo, veamos qué comandos entiende generalmente nuestra pantalla. Para ello, nos adentramos en la hoja de datos y encontramos una tabla interesante:

Aquí se describen todos los comandos y señales que deben estar en los pines correspondientes del WH1602 para cada comando específico. Por ejemplo, queremos borrar la pantalla, miramos la tabla y aquí está el comando que necesitamos. ¡Pantalla clara!

Aplicamos ceros a los pines RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 y uno al pin DB0. ¡Listo! ¿Qué sigue? Así es, uno en el pin E, luego espera un rato y baja E a cero nuevamente. Eso es todo, la pantalla se borra 😉 Justo antes de ejecutar el siguiente comando debes hacer una pausa, indicada en la hoja de datos de cada comando. Sería más efectivo sondear el indicador de ocupado; tan pronto como se restablezca a 0, podrá continuar trabajando. También hay un comando especial para leer esta bandera, por lo que todo queda claro con esto) Sigamos adelante...

Y, de hecho, todo es teoría, ya puedes intentar escribir algo. Para facilitar el trabajo con la pantalla, creé una pequeña biblioteca, ahora veamos cómo se puede usar. Primero, descargar

Tenemos 2 archivos a nuestra disposición, MT_WH1602.c y MT_WH1602.h. Arrancamos el segundo, aquí debemos seleccionar los pines y el controlador utilizado.

Por cierto, mi pantalla está conectada así:

RS-PC2
R/E – PB10
E–PB14
DB7-PD2
DB6-PC12
DB5-PA8
DB4–PA10
DB3–PA15
DB2-PD11
DB1-PA3
DB0–PA5

Abra el archivo MT_WH1602.h:

#definir PLATAFORMA (STM32F10x)

A continuación, seleccione los pines del microcontrolador a los que está conectada la pantalla. Primero, configuremos qué puertos usamos. Cuando me conecto, uso GPIOA, GPIOB, GPIOC y GPIOD, escribimos:

Lo mismo ocurre con otras patas del microcontrolador.

Terminamos con la configuración, continuemos) Para llamar a los comandos dados al principio del artículo, el archivo MT_WH1602.c contiene las siguientes funciones (llevan el nombre de los nombres de los comandos, así que creo que todo está claro) :

anular MT_WH1602_ClearDisplay (anular); vacío MT_WH1602_ReturnHome(vacío); void MT_WH1602_EntryModeSet (dirección ID bool, cambio bool); anular MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit); anular MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit); void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit); void MT_WH1602_SetCGRAMAddress (dirección uint8_t); void MT_WH1602_SetDDRAMAddress (dirección uint8_t); bool MT_WH1602_ReadBusy(vacío); anular MT_WH1602_WriteData (datos uint8_t);

Para algunos comandos necesitamos pasar parámetros a la función, por ejemplo:

void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit);

Veamos la tabla de comandos:

Vemos que el comando Display ON/OFF no sólo enciende/apaga la pantalla, sino que también activa/desactiva el cursor y el parpadeo del cursor. En la hoja de datos, estos bits de comando se designan como D, C y B, y los pasamos como parámetros a la función. Si necesitamos encender la pantalla y el cursor, pero desactivar el parpadeo del cursor, llamamos al comando de la siguiente manera:

MT_WH1602_DisplayOnOff(1, 1, 0);

En general, todo es sencillo 😉

En resumen, creamos nuevo proyecto, agregue una biblioteca para trabajar con la pantalla WH1602, cree un archivo .c vacío y comience a llenarlo con código:

// Incluir el archivo de la biblioteca#incluir "MT_WH1602.h" /*******************************************************************/ int principal (vacío) ( // Llama a la función de inicialización, no podemos prescindir de ella =)() ; // Ahora necesitamos realizar la configuración de visualización inicial. // La documentación e Internet recomiendan hacer esto;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000); MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_ClearDisplay(); MT_WH1602_Delay(2000); // Por ejemplo, tomé los primeros valores de retraso que me vinieron a la mente) // En general, es necesario comprobar el indicador de visualización ocupada // Ahora mostremos algo, como el nombre de nuestro sitio. MT_WH1602_WriteData(0x6D); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x69); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x72); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x6F); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x74); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x65); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x68); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x6E); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x69); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x73); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x2E); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x72); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x75); MT_WH1602_Delay(100); mientras (1) ( __NOP() ; ) ) /*******************************************************************/

Listo, comprobemos)

Como puedes ver, todo funciona correctamente)

Por cierto, de alguna manera perdí de vista la cuestión de qué escribir en la pantalla para mostrar tal o cual carácter. Aquí está la placa de la hoja de datos:

Entonces, para determinar qué valor escribir en la memoria de la pantalla, debe tomar los números escritos en la parte superior e izquierda de esta tabla para un símbolo específico. Por ejemplo, el símbolo "A". Veamos: este símbolo corresponde a la columna 0100 (0x4) y la línea 0001 (0x1). Resulta que para mostrar el símbolo "A" necesitas escribir el valor 0x41 en la pantalla.

Eso es todo =) Hemos solucionado la conexión y el funcionamiento de la pantalla WH1602, ¡hasta pronto!

PD Cuando trabajaba con la biblioteca, no probé la función de leer el indicador de ocupado, así que si de repente algo no funciona como debería, escribe, lo resolveremos)

A veces nos enfrentamos al problema de enviar información diversa desde Arduino al mundo exterior. A menudo, utilizar un puerto serie es imposible, inconveniente y no rentable.

Una pantalla de caracteres es uno de los medios más simples y económicos de mostrar información porque tiene su propio microcontrolador que almacena los caracteres codificados. Este sistema simplifica el uso de estas pantallas, pero al mismo tiempo limita su uso solo a la salida. información de texto, a diferencia de las pantallas gráficas.

En el ejemplo, veremos la pantalla Winstar wh1602l1, una de las pantallas más comunes en el controlador hd44780. Además, puedes conectar LCD 2004 y otros similares.
Los dos primeros dígitos indican el número de caracteres por línea, y el segundo el número de líneas, por lo que la pantalla seleccionada tiene 2 líneas de 16 caracteres.
Este método de conexión implica ocupar al menos 6 puertos del microcontrolador Arduino. Si es necesario, puede conectar la pantalla de texto 1602 a través de la interfaz I2C (2 puertos).

De los elementos adicionales que necesitamos resistencia variable, para controlar el contraste. De lo contrario, todo está conectado según el diagrama, según la hoja de datos y las salidas Arduino seleccionadas en el programa.

Los pines 15 y 16 de la pantalla son responsables de la iluminación de fondo, se puede apagar o ajustar automáticamente el brillo al conectar un fotorresistor al Arduino como sensor de brillo.

En nuestro ejemplo, leeremos datos del puerto serie y los mostraremos en la pantalla:

#incluir // Conecte la biblioteca para trabajar con pantallas de caracteres LiquidCrystal lcd(13, 11, 5, 4, 3, 2); // (RS, E, D4, D5, D6, D7) conecte las salidas de la pantalla de acuerdo con la secuencia, R/W – GND, ya que escribiremos datos en la pantalla y no leeremos void setup() ( lcd.begin( 16, 2); // Inicializa LCD 1602 // lcd.begin(20, 4); // Inicializa LCD 2004 Serial.begin(9600); // Inicia el puerto serie ) void loop() ( if (Serial.available ()) // Si los datos provienen del puerto, entonces... ( delay(100); lcd.clear(); // Borra completamente la pantalla mientras (Serial.available() > 0) // Si los datos provienen de el puerto mayor que 0, entonces... ( lcd.write(Serial.read()); // Lee los valores del puerto serie y los muestra en la pantalla ) )

Puede complicar el código y enviar el reloj en tiempo real DS1307 de Arduino a su LCD1602.

Ahora echemos un vistazo más de cerca a todas las funciones de la biblioteca. Cristal liquido:

Lo primero y más importante es que al utilizar esta biblioteca no se pueden mostrar letras rusas, incluso si la pantalla tiene estos caracteres en la memoria. Este problema se puede resolver con otras bibliotecas o escribiendo valores utilizando código hexadecimal.

lcd.imprimir();- el más simple y utilizado con mayor frecuencia, utilizado para mostrar información.

pantalla LCD. claro(); - utilizado para limpiar la pantalla.

lcd.setCursor(X, y); - coloca el cursor en un lugar específico.

X – cambio de posición en la línea

Y – cambio de línea

Por ejemplo, lcd.setCursor(0, 0); esta es la celda superior izquierda.

lcd.casa(); - coloca el cursor en la posición 0, 0

lcd.casa(); = lcd.setCursor(0, 0);

pantalla LCD. desplazamientoPantallaIzquierda(); - desplazamiento a la izquierda

pantalla LCD. desplazarsePantallaDerecha(); - cambio a la derecha

Lcd.createChar(Nombre, formación); - creando tu propio letrero.

Por ejemplo, el signo de grado se ve así: