Representar Mensaje en LCD

Buenas a todos, en esta práctica os voy a dar las directrices para poder escribir mediante nuestro soporte xilinx un mensaje de texto. Puesto que para poder visualizarlo vamos a precisar de un LCD, en este caso alfanumérico, mi consejo es que comencemos estudiando el LCD que vamos a utilizar. Esto lo digo porque cada LCD tiene sus propias conexiones y características, y por tanto, diferentes maneras de comunicarse. Este es un pequeño listado de las características.

Pantalla de cristal líquido con una matriz de 2 x 16 caracteres de 5 x 7 píxeles.

Microcontrolador propio de gobierno. (Hitachi μC44780)

Desplazamiento de los caracteres hacia la izquierda o hacia la derecha.

Proporciona la dirección de la posición absoluta o relativa del carácter.

Memoria de 40 caracteres por la línea de pantalla.

Movimiento del cursor y cambio de aspecto.

8 caracteres programables por el usuario.

Conexión a un procesador usando interfaz de 4/8 bits.

Además, os muestro su forma de conexión física.

VSS.- Patilla de GND de alimentación.

VCC.- Patilla de alimentación de +5V.

VEE.- Patilla de contraste del cristal líquido. Normalmente, se conecta a un potenciómetro a través del cual se aplica una tensión variable entre 0 y +5V que permite regular el contraste del cristal líquido.

RS.- Selección del registro de control/datos:

RS=0 Registro de control.

RS=1 Registro de datos.

R/W.- Señal de lectura/escritura:

R/W= 0 EL módulo LCD es escrito.

R/W= 1 EL módulo LCD es leído.

E.- Señal de activación del módulo LCD:

E=0 Módulo desconectado. Las líneas D0-D7 quedan en estado de alta impedancia.

E=1 Módulo conectado.

D0-D7.- Bus de datos bidireccional. A través de estas líneas se realiza la transferencia de información entre el módulo LCD y el sistema de control.

En definitiva nuestro proceso de trabajo se va a basar en un diagrama de estados que irá realizando unas funciones en un orden determinado y hará que se escriba en nuestra pantalla del lcd un mensaje. En este caso “GABRIEL ALLENDE © 2011”.

El protocolo a seguir es el siguiente:

-Secuencia de inicio

-Pantalla ON/OFF

-Cursor a casa

-Escritura en la primera línea

-Salto de línea

-Escritura en segunda línea

Una vez conocemos el protocolo, será el momento de comenzar con la creación del proyecto.

Para eso, como siempre abrimos xilinx y le damos a “file”, “new Project”, y creamos una fila del tipo esquemático y la guardamos en la ruta que deseemos. Después nos pedirá la configuración de los parámetros principales, que deberéis copiar de aquí.

Una vez tengamos el proyecto creado tendremos que añadirle las fuentes. En este caso le vamos a añadir un esquema. Por lo que daremos botón derecho “new source” y seleccionaremos esquemático, en la que meteremos los dos contadores. Y también le añadiremos otra fuente que será un diagrama de estados. Por lo que para eso, daremos botón derecho y marcaremos “new source”, elegiremos state diagram y listo.

Ya tenemos nuestro proyecto con nuestras dos fuentes creadas. Ahora nos meteremos en el diagrama de estados del LCD (state cad), para ir construyendo nuestro proceso de máquina de estados.

En primer lugar una vez estemos dentro del state cad, lo que tendremos que hacer es ir incorporando todas las variables que pretendemos utilizar. Mi consejo es que guardéis un orden, puesto que son muchas variables a introducir y va a ser fácil perderse.

Si echáis un vistazo, veréis que tanto el reset como el three state están en bajo activo, no es ningún fallo funcionen en bajo activo, son las salidas con registros.

Una vez tengamos declaradas las variables, será el momento de empezar a desarrollar el diagrama de estados, que es bastante extenso. En primero lugar lo que haré será ir explicándolo por partes.

La secuencia de inicio:

                                     

Ignorar los 3 estados tachados por la línea roja, así como el amarillo de más a la izquierda. Esos no son elementales para el inicio. Esta parte va desde el estado 0 hasta el 9, haciendo un salto del 5 al 9.

Vamos por partes.

Estado 0:

Como veis, todos los elementos declarados dentro del estado, están a cero. Sin embargo, si recordáis, el “three state” trabaja en bajo activo y por tanto, está activado, esto se traduce a que las salidas del autómata quedan en alta impedancia. Además de eso, le añadimos un reset, también en cero, porque trabaja en bajo activo.

Pasamos al siguiente estado sin ninguna condición.

Estado 1:

En este caso ponemos el reloj registro en 1 para aumentar la cuenta en el contador de comandos. 

Pasamos al estado 2 sin condiciones.

Estado 2:

Ponemos el “habilitar” en uno para activar el LCD y el “read write” para hacer que se ponga en lectura.

Pasamos  al estado 3 sin condiciones.

 

Le ponemos igual que el estado anterior solo que añadimos  una condición por la cual si “D7_I=’1’” permanecerá en ese estado.

Pasamos al estado 4 si “D7_I = ‘0’  “.

Estado 4:

 

En el estado cuatro pasamos al cinco 3 veces seguidas para hacer la función de secuencia de inicio que necesita el LCD para activarse.

Estado 5:

Mantenemos el Three state a 1 y el habilitar al 1 también.

Pasamos al estado 9 sin condiciones.

Recordemos que, como dije anteriormente, tenemos que hacer la llamada 3 veces, esta llamada para saber si han sido realmente 3 veces, hemos utilizado un contador de 5 bits. De no ser así, volveremos al estado 0.

Bien, puesto que podemos pasar del 9 al 0 por lo que os acabo de decir, las transiciones  serán las siguientes. Es decir, vamos al estado cero cuando…

 [Q0_R='1' & Q1_R='0' & Q2_R='0'] ó

 [Q0_R='0' & Q1_R='1' & Q2_R='0'] ó

 [Q0_R='1' & Q1_R='1' & Q2_R='0'].

Vamos a dar un pequeño paso para atrás. En el ESTADO 4, vamos a abrir unas cuantas transiciones que antes me salté para no interferir en el proceso de inicio. Desde el estado cuatro sacaremos una transición que vaya a un estado que deje la pantalla encendida, el cursor en ON y el parpadeo del cursor en ON. En este caso el estado 6. La transición que hay entre el estado 4 y el 6 es esta:” Q0_R='0' & Q1_R='0' & Q2_R='1' ”

Del estado 6 al 9 pasaremos sin incorporar ninguna transición.

Haremos algo parecido con el estado 7, en su caso, el objetivo de este estado es mandar el cursor a casa. (Para los que no lo entiendan es hacer que el cursor vaya al inicio del LCD es decir, a la parte superior izquierda de la pantalla).

Lo que se encuentra en el recuadro rojo es la condición entre el estado 4 y el 7. Del 7 al 9 pasamos sin condiciones.

Después nos vamos al estado 10. Este va a ser un estado que va a recoger muchas transiciones. En él pondremos la salida del reloj_dato en 1. Con esto incrementamos la cuenta de datos del contador.

Del 10 pasamos al 11 sin condiciones. 

En él habilitamos el LCD y lo ponemos en modo lectura.

El estado 12 es igual que el 11, solo que lleva consigo una transición que tiene inicio y fin en el mismo estado 12. La condición es  “D7_I=’1’ “. Con esto evitamos que se pase al estado 13 si la máquina se mantiene  ocupada.

Ahora viene uno de los estados más importantes de todos. El estado 13 es el que se “comunica” entre todos los caracteres del LCD. Contando también los espacios. 

En él activamos el “rs” es decir el modo de dato. Una vez tengamos esto es hora de comunicar este estado con todos los caracteres. Como las transiciones son un número bastante grande, voy a copiar primero las de la primera línea:

Al STATE14 si [Q0_D='1' & Q1_D='0' & Q2_D='0' & Q3_D='0' & Q4_D='0']

al STATE15 si [Q0_D='0' & Q1_D='1' & Q2_D='0' & Q3_D='0' & Q4_D='0']

al STATE16 si [Q0_D='1' & Q1_D='1' & Q2_D='0' & Q3_D='0' & Q4_D='0']

al STATE17 si [Q0_D='0' & Q1_D='0' & Q2_D='1' & Q3_D='0' & Q4_D='0']

al STATE18 si [Q0_D='1' & Q1_D='0' & Q2_D='1' & Q3_D='0' & Q4_D='0']

al STATE19 si [Q0_D='0' & Q1_D='1' & Q2_D='1' & Q3_D='0' & Q4_D='0']

al STATE20 si [Q0_D='1' & Q1_D='1' & Q2_D='1' & Q3_D='0' & Q4_D='0']

al STATE21 si [Q0_D='0' & Q1_D='0' & Q2_D='0' & Q3_D='1' & Q4_D='0']

al STATE22 si [Q0_D='1' & Q1_D='0' & Q2_D='0' & Q3_D='1' & Q4_D='0']

al STATE23 si [Q0_D='0' & Q1_D='1' & Q2_D='0' & Q3_D='1' & Q4_D='0']

al STATE24 si [Q0_D='1' & Q1_D='1' & Q2_D='0' & Q3_D='1' & Q4_D='0']

al STATE25 si [Q0_D='0' & Q1_D='0' & Q2_D='1' & Q3_D='1' & Q4_D='0']

al STATE26 si [Q0_D='1’ & Q1_D='0' & Q2_D='1' & Q3_D='1' & Q4_D='0']

al STATE27 si [Q0_D='0' & Q1_D='1' & Q2_D='1' & Q3_D='1' & Q4_D='0']

al STATE28 si [Q0_D='1' & Q1_D='1' & Q2_D='1' & Q3_D='1' & Q4_D='0']

al STATE29 si [Q0_D='0' & Q1_D='0' & Q2_D='0' & Q3_D='0' & Q4_D='1']

Estas serían las transiciones de todos los estados que componen la primera línea. Ahora, dentro de cada estado, vamos a tener que ir escribiendo los caracteres. Para eso haremos uso de una tabla para conocer los códigos de cada letra. Esta tabla me la mostró un amigo de clase, para mi gusto, la que mejor se entiende.

Yo aproveché y directamente me construí una tabla en la que iba metiendo los caracteres que necesitaba, para hacerlo directamente, pero por desgracia no la encuentro. 

Esto sería un ejemplo de parte de los caracteres. Dependiendo que salidas activemos formaremos un código y, por tanto, una letra. En mi caso añadí con espacios la parte de arriba que me sobraba para que bajara a la siguiente línea, digamos que este método es más trabajoso, pero una vez que ya llevas un rato haciendo el código se va a piñón fijo, añades espacios hasta que baje y escribes después, listo. Una vez tengamos todas, pasamos al estado 38 sin ninguna condición. Como os muestro en la imagen.

Del 38 pasamos al estado 39 sin ninguna condición. Y por último añadiremos el estado  40, en el cual activaremos el “puesta a 0”. En este estado se reinician los contadores para no perder el control del programa. Una vez tengamos esto, ya habremos acabado nuestra máquina finalizada.

Como siempre ahora toca llevar el proceso de “verificación de funcionamiento”, mediante el testeo de estados.

Una vez veamos que nuestro programa ha pasado por todos y cada uno de los estados, significa que nos funciona y entonces pasaremos a generar el VHDL.

Una vez le demos, nos saldrá el código del programa y nos dirá que la compilación se realizó con éxito.

Entonces pasaremos a incorporar el código. Para eso botón derecho desde el ISE, “Add existing sources”, con esto meteremos el código VHDL anteriormente elaborado  y crearemos  un nuevo símbolo con “create a schematic symbol”.

Tendremos que diseñar un esquemático bastante complejo en el que están los 2 contadores, así como la máquina de estados, la cual, ahora, tiene su código Vhdl integrado. Este sería el diseño del esquemático.

Está compuesto por los siguientes componentes.

-Dos contadores, uno de 4 bits (CB4CE) y otro de 8 bits(CB8CE).

-1 BUFG

-8 OBUFT

-8 IBUF

-1 INV

-1OR

-1AUTOMATA LCD1

-8 BUFT

 

Una vez que tengamos acabado nuestro esquemático con todos los componentes, es hora de pasar al entorno PACE, por eso, abriremos el archivo con extensión UCF. Con eso, colocaremos como deseemos nuestros pines y ya estaría finalizado.

Ya nos encontramos en el punto final, es decir, al tener todos los archivos, esquemático, el diagrama de bloques, tener integrado el vhdl en la máquina y demás, ya será hora de darle a “generate pogramming file” para que nos genere el JED y ya está acabado. Espero que os halla servido de ayuda.  UN SALUDO!



AQUÍ LA DESCARGA