- Materiales necesarios
- Módulo de pantalla LCD 16X2
- Diagrama de circuito y conexiones
- Programación ARM7-LPC2148
La pantalla es la parte necesaria de una máquina, ya sea un electrodoméstico o una máquina industrial. La pantalla no solo muestra las opciones de control para operar la máquina, sino que también muestra el estado y la salida de la tarea realizada por esa máquina. Hay muchos tipos de pantallas que se utilizan en la electrónica, como la pantalla de 7 segmentos, la pantalla LCD, la pantalla táctil TFT, la pantalla LED, etc. La pantalla LCD de 16x2 es la más básica y también se utiliza en algunos equipos electrónicos pequeños, hemos hecho muchos proyectos que utilizan LCD de 16x2, incluida la interfaz básica con otros microcontroladores:
- Interfaz LCD con microcontrolador 8051
- Interfaz LCD con microcontrolador ATmega32
- Interfaz LCD con microcontrolador PIC
- Interfaz LCD 16x2 con Arduino
- Interfaz LCD 16x2 con Raspberry Pi usando Python
En este tutorial, veremos cómo conectar una pantalla LCD de 16x2 con el microcontrolador ARM7-LPC2148 y mostrar un simple mensaje de bienvenida. Si es nuevo con ARM7, comience con los conceptos básicos de ARM7 LPC2148 y aprenda cómo se puede programar usando Keil uVision
Materiales necesarios
Hardware
- Placa de microcontrolador ARM7-LPC2148
- LCD (16X2)
- Potenciómetro
- Regulador de voltaje 5V IC
- Tablero de circuitos
- Conexión de cables
- Batería de 9V
- Cable micro USB
Software
- Keil uVision 5
- Herramienta de flash mágico
Antes de adentrarnos en el proyecto debemos conocer algunas cosas sobre los modos de funcionamiento del LCD y sobre los códigos LCD Hex.
Módulo de pantalla LCD 16X2
Una pantalla LCD de 16X2 dice que tiene 16 columnas y 2 filas. Esta pantalla LCD tiene 16 pines. La siguiente imagen y tabla muestra los nombres de los pines de la pantalla LCD y sus funciones.
|
NOMBRE |
FUNCIÓN |
|
VSS |
Pin de tierra |
|
VDD |
Pin de entrada de + 5V |
|
VEE |
Pin de ajuste de contraste |
|
RS |
Registrarse Seleccionar |
|
R / W |
Pin de lectura / escritura |
|
mi |
Habilitar Pin |
|
D0-D7 |
Pines de datos (8 pines) |
|
LED A |
Pin de ánodo (+ 5V) |
|
LED K |
Pin de cátodo (GND) |
La pantalla LCD puede funcionar en dos modos diferentes, a saber, el modo de 4 bits y el modo de 8 bits. En el modo de 4 bits enviamos los datos nibble por nibble, primero nibble superior y luego nibble inferior. Para aquellos de ustedes que no saben qué es un nibble: un nibble es un grupo de cuatro bits, por lo que los cuatro bits inferiores (D0-D3) de un byte forman el nibble inferior mientras que los cuatro bits superiores (D4-D7) de un byte forman el nibble más alto. Esto nos permite enviar datos de 8 bits.
Mientras que en el modo de 8 bits podemos enviar los datos de 8 bits directamente de un solo golpe, ya que usamos las 8 líneas de datos.
Aquí en este proyecto usaremos el modo más comúnmente usado que es el modo de 4 bits. En el modo de cuatro bits podemos ahorrar 4 pines del microcontrolador y también reducir la sobrecarga del cableado.
16x2 también usa código HEX para tomar cualquier comando, hay muchos comandos hexadecimales para LCD como mover el cursor, seleccionar el modo, cambiar el control a la segunda línea, etc. Para saber más sobre el módulo de pantalla LCD 16X2 y los comandos hexadecimales, siga el enlace.
Diagrama de circuito y conexiones
La siguiente tabla muestra las conexiones del circuito entre LCD y ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Seleccionar registro) |
|
P0.6 |
E (habilitar) |
|
P0.12 |
D4 (pin de datos 4) |
|
P0.13 |
D5 (pin de datos 5) |
|
P0.14 |
D6 (pin de datos 6) |
|
P0.15 |
D7 (pin de datos 7) |
Conexiones del regulador de voltaje con LCD y ARM7 Stick
La siguiente tabla muestra las conexiones entre ARM7 y LCD con regulador de voltaje.
|
Regulador de voltaje IC |
Función pin |
LCD y ARM-7 LPC2148 |
|
1.Pin izquierdo |
+ Ve de la batería Entrada 9V |
CAROLINA DEL NORTE |
|
2.Pin central |
- Ve de la batería |
VSS, R / W, K de LCD GND de ARM7 |
|
3.Pin derecho |
Salida regulada de +5 V |
VDD, A de LCD + 5V de ARM7 |
Potenciómetro con LCD
Se utiliza un potenciómetro para variar el contraste de la pantalla LCD. Una olla tiene tres pines, el pin izquierdo (1) está conectado a + 5V y el centro (2) a VEE o V0 del módulo LCD y el pin derecho (3) está conectado a GND. Podemos ajustar el contraste girando el mando.
Configuración del puente
Un pin de puente está presente en ARM7-Stick para que podamos encender y cargar el código usando USB o usando una entrada de 5V DC solo para energía. Puedes ver las imágenes de abajo.
La imagen de abajo muestra que el puente está en la posición DC. Eso significa que debemos alimentar la placa con una fuente externa de 5V.
Y esta imagen muestra que el puente está conectado en modo USB. Aquí, la alimentación y el código se proporcionan a través del puerto micro USB.
NOTA: Aquí, en este tutorial, hemos cargado el código usando USB al configurar el puente en USB y luego cambiamos el puente al modo CC para alimentar LPC2148 desde la entrada de 5v del regulador. Puedes ver esto en el video que se encuentra al final.
El circuito final para interconectar la pantalla LCD 16x2 con el microcontrolador ARM7 se verá así:
Programación ARM7-LPC2148
Para programar ARM7-LPC2148 necesitamos la herramienta keil uVision y Flash Magic. Estamos usando un cable USB para programar ARM7 Stick a través del puerto micro USB. Escribimos código usando Keil y creamos un archivo hexadecimal y luego el archivo HEX se actualiza a la barra ARM7 usando Flash Magic. Para saber más sobre la instalación de keil uVision y Flash Magic y cómo usarlos, siga el enlace Comenzando con el microcontrolador ARM7 LPC2148 y prográmelo usando Keil uVision.
El código completo para interconectar LCD con ARM 7 se proporciona al final de este tutorial, aquí explicamos algunas partes.
En primer lugar, debemos incluir los archivos de encabezado necesarios
#incluir
Inicializar el módulo LCD es un paso muy importante. Aquí utilizamos ciertos códigos HEX, que en realidad son comandos, para informar a la pantalla LCD sobre el modo de funcionamiento (4 bits), el tipo de pantalla LCD (16x2), la línea de inicio, etc.
void LCD_INITILIZE (void) // Función para preparar el LCD { IO0DIR = 0x0000FFF0; // Establece el pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 como SALIDA delay_ms (20); LCD_SEND (0x02); // Inicializar lcd en modo de operación de 4 bits LCD_SEND (0x28); // 2 líneas (16X2) LCD_SEND (0x0C); // Mostrar en cursor apagado LCD_SEND (0x06); // Cursor de incremento automático LCD_SEND (0x01); // Mostrar claro LCD_SEND (0x80); // Primera línea, primera posición }
Para el modo de 4 bits, tenemos un tipo diferente de función de escritura para los pines, es decir, usando un nibble superior e inferior. Veamos como se hace
void LCD_SEND (comando char) // Función para enviar comandos hexadecimales nibble por nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0xF0) << 8)); // Enviar el nibble superior del comando IO0SET = 0x00000040; // Haciendo Habilitar HIGH IO0CLR = 0x00000030; // Haciendo que RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Habilitar habilitación BAJA delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0x0F) << 12)); // Enviar el nibble inferior del comando IO0SET = 0x00000040; // HABILITAR ALTO IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // HABILITAR LOW delay_ms (5); }
Lógica de envío de Nibble
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0x0F) << 12)); // Enviar el nibble inferior del comando IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0xF0) << 8)); // Enviar el nibble superior del comando
Las dos declaraciones anteriores juegan un papel importante en este programa. El primer comando envía el nibble inferior y el segundo envía el nibble superior. Eso es sin afectar los otros pines que hacemos. Veamos cómo está sucediendo antes de que conozca esta lógica primero
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Entonces usamos un concepto de enmascaramiento y una operación de cambio lógico sin afectar a los otros pines. Significa que solo se utilizan los pines (P0.12-P0.15) y no se ven afectados otros pines como P0.4, P0.6. Se hará cambiando los datos en cuatro bits y haciendo el nibble superior en el lugar del nibble inferior y enmascarando el nibble superior. Y luego ponemos los bits inferiores en cero (0XF0) y hacemos un OR con los datos del nibble para obtener los datos del nibble superior en la salida.
Se utiliza un proceso similar para datos de nibble menor, pero aquí no es necesario cambiar los datos.
Mientras se escriben datos en la salida, es decir, en el modo de comando, RS debe ser BAJO y para ejecutar la habilitación debe ser ALTA, y en el modo de datos RS debe ser ALTA y para ejecutar la habilitación debe ser ALTA.
Ahora, para enviar los datos de la cadena que se imprimirán en la salida, se utiliza el mismo principio nibble por nibble. Un paso importante aquí es REGISTRO SELECCIONADO (RS) debe ser ALTO para el modo de datos.
void LCD_DISPLAY (char * msg) // Función para imprimir los caracteres enviados uno a uno { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envía el nibble superior IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH para imprimir datos IO0CLR = 0x00000020; // RW LOW Retardo del modo de escritura ms (2); IO0CLR = 0x00000040; // EN = 0, RS y RW sin cambios (es decir, RS = 1, RW = 0) retardo ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envía un nibble inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; retraso ms (2); IO0CLR = 0x00000040; retraso ms (5); i ++; }
El video completo de codificación y demostración se muestra a continuación.