Obtenemos mediante karnaugh que:

S= A ⊕ B ⊕ Cin

Cout= AB+Cin(A+B)

Otra manera de expresar el acarreo de salida es Cout = AB + Cin (A⊕ B), y así nos ahorramos una puerta OR.

El proceso de diseño que se utilizará para crear el proyecto del sumador es el XILINX ISE 10.1.

*Esquema a diseñar:

Abrimos XILINX ISE 10.1

1. En la esquina superior izquierda se muestran las distintas fuentes de diseño, que pertenecen al proyecto organizadas jerárquicamente.

2. Debajo de las fuentes se encuentra la ventana de Procesos. En esta ventana se mostrará la lista de procesos disponibles para la fuente seleccionada en la ventana superior. Para cada proceso se muestra el estado del mismo, si ha sido ejecutado y, en caso afirmativo, si el resultado ha sido correcto.

Dependiendo de la fuente de diseño los procesos disponibles son distintos.

3. La tercera ventana está situada en la parte inferior de la pantalla. Ésta es la consola de Mensajes, que se actualiza con mensajes informativos y de advertencia a medida que se activan los distintos procesos.

4. La última ventana se sitúa a la derecha y es un editor de HDL, entre otras muchas cosas.

2.Creamos un nuevo proyecto.

Ir a ‘File->New Project’ y nos aparecerá la siguiente imagen, donde configuramos los primeros parámetros del proyecto.

En primer lugar seleccionamos la ubicación del proyecto “Project location”, después damos un nombre al proyecto “sumador1”,y al mismo tiempo se nos crea una carpeta en el directorio anteriormente seleccionado `C:\Users\esmelis\documents\proyectos xilinx\sumador1´, y por ultimo seleccionamos la entrada del proyecto que en nuestro caso será “Schematic”.

Hacemos clic en siguiente y se nos abrirá la siguiente ventana:

Family —> es la familia a la cual pertenece el cpld a utilizar “XC95500 CPLDs”.
Device—> dispositivo cpld que utilizaremos XC9572.
Package—> es el tipo de encapsulado del cpld a utilizar “PC84”.

Speed–> es la velocidad de trabajo del cpld. El dato viene en nano segundos y se refiere al retardo pin a pin. La selección depende del dispositivo que dispongamos, en nuestro caso elegimos ‘-7’.

Design Flow: En este apartado seleccionamos el tipo de entrada (Schematic), el sintetizador (XST para VHDL), el simulador (ISE Simulator) y el lenguaje de simulación utilizado (VHDL).

Le damos a siguiente y nos sale la ventana donde se nos pide que creemos o añadamos una fuente nueva, hacemos clic en new source:

Vamos a añadir una fuente a nuestro proyecto para especificar los requerimientos del sistema utilizando un lenguaje formal de presentación gráfico.

En la ventana que nos aparecerá a continuación seleccionamos la plantilla schematic y asignamos un nombre a la fuente “sumador”, la opción add to project debe estar activada.

A continuación se crea un informe:

En esta ventana hacemos clic en ‘Siguiente’.

Se nos da la posibilidad de añadir más ficheros fuentes. En nuestro caso no añadiremos más.

Se nos crea el siguiente informe con las especificaciones del nuevo proyecto:

Le damos a finish para concluir.

Si todo está correcto, aparecerán dos nuevas entradas dentro de la ventana de ‘Fuentes de Diseño’ del proyecto. Una con el nombre del proyecto ‘sumador.sch’, y la otra con el nombre del dispositivo CPLD ‘XC9572-7pc84.

Ahora estamos listos para diseñar nuestro esquema del contador de 1 bit.

3.Diseñar esquema del contador.

Lo primero que haremos es añadir los símbolos de los componentes, para eso nos iremos a symbols y se nos abre la ventana de símbolos, mostrándonos las librerías y sus componentes correspondientes.

El primer componente que vamos a colocar es una puerta xor de 2 entradas ‘xor2’. Para ello, tenemos dos formas de hacerlo:

Seleccionando ‘All Symbols’ y escribiendo ‘xor2’ en ‘Symbol Name Filter’. Posteriormente arrastramos el símbolo con el ratón hasta colocarlo en el lugar deseado dentro del esquemático.

La otra manera, es seleccionando la categoría ‘Logic’ y escribiendo ‘xor2’ en ‘Symbol Name Filter’ o buscando directamente dentro de la librería.

Posteriormente, arrastramos el símbolo con el ratón hasta colocarlo en el lugar deseado dentro del esquemático.

El resto de los componentes lo colocamos de la siguiente manera en el esquemático:

4.Trazamos las líneas de conexión de los componentes.

Desde la barra de menús, seleccionamos ‘Add->Wire’ o hacemos clic en el icono de la barra de herramientas.

Si la línea a dibujar va de un pin hasta otro, haremos clic en el pin fuente y, llevando el ratón hasta el pin de destino, volveremos a hacer clic en este pin.

En la siguiente imagen muestra como tendrían que ir conexionados los componentes:

Desde la barra de menús, seleccionamos ‘Add->Net Name’ o hacemos clic en el icono de la barra de herramientas.

Escriba el nombre ‘A’ en la caja de ‘Name’ tal y como señala la Figura: wire name Notará cómo en el cursor del ratón se añade el nombre ‘A’ y haciendo clic en la línea que se quiera nombrar, esta tomará el nombre, y así con las demás líneas se añaden los nombres de (B, Cin, Cout y S).

5.Añadiendo las marcas I/O.

Todas las líneas que vayan a tener conexión con el exterior del CPLD, deben ser marcadas.

Desde la barra de menús, seleccionamos ‘Add->I/O Marker’ o hacemos clic en el icono de la barra de herramientas.

Las ‘I/O Markers’ pueden ser de entrada, salida o bidireccionales, por lo que deberemos elegir el tipo de marca antes de proceder a su colocación.

Para colocar una marca basta con situarse encima del nombre de la net y hacer clic. En el caso de no haber sido nombrada la net, el ‘ECS’ pondrá un nombre tomando como referencia parámetros internos.

Una vez teniendo todo conexionado verificamos los errores que hayamos cometido en el diseño a nivel de conexionado, para eso haremos clic en el siguiente botón que muestra la figura siguiente:

Vemos que en el cuadro rojo inferior que aparece en la consola de mensajes de la figura de arriba nos dice que no hay errores un warnig, esto quiere decir que esta todo correcto.

6.Creación del fichero Test Bench waveform.

El test bench es un fichero VHDL en el que se instancia la entidad que se desea probar ‘uut’ (unit under test).

El primer paso es crear el fichero de test bench. Pulsando el botón derecho sobre el fichero `sumador.sch’ seleccionamos la opción de ‘New Source’. En la siguiente pantalla elegimos la opción de ‘New->Test Bench Waveform’, y le llamamos ‘sum_1’.

Luego seleccionamos next y nos aparecerá la siguiente ventana la cual asociamos el fichero de test bench a sumador.

Una vez hecho esto, se abrirá una ventana donde podemos configurar los tiempos de la simulación.

Este diseño no contiene ningún tipo de señal de reloj, por lo que se requiere seleccionar entradas combinacionales para realizar la simulación “Combinatorial (or internal clock)”.

Los tiempos de retardos los dejamos por defecto. Chequeamos las salidas 50ns después de que las entradas son asignadas y asignamos las entradas 50ns después que las salidas son chequeadas, damos a finish.

Ahora ‘HDL Bencher’ se nos abre dentro del entorno ‘ISE’ mostrándonos las formas de onda.

Ahora comprobaremos la tabla de verdad del sumador completo de 1 bit.

Simplemente hacemos clic izquierdo sobre el fondo azul de las entradas, hasta realizar todas las combinaciones posibles que muestra la tabla de verdad.

Una vez hecho esto cerramos las formas de ondas y guardamos.

En la siguiente imagen vemos como se nos ha creado el fichero de test “sum_1.tbw” en la fuente para el post-fit simulation y a su vez contiene una rama que es el vhd de la simulación “UTT-SUMADOR”.

Ahora simulamos con xilinx ise simulator.

7. Simulación con XILINX ISE SIMULATOR

En la imagen se puede ver en los cuadros rojos el fichero de test que se ha creado y el simulate post-fit model.

Ahora bien se selecciona el fichero”sum_1 (sum_1.tbw), y luego hacemos doble clic en simulate post-fit model y obtendremos la siguiente grafica que muestra la imagen a continuación.

En la ventana anterior se puede visualizar de las formas de onda. En esta ventana se visualiza una representación gráfica de la evolución de la simulación a lo largo del tiempo.

8.Análisis de la simulación.

Una vez visualizada las formas de ondas de las entradas y salidas, se analizan los tiempos de estas.

9.Síntesis del sumador.

El ‘ISE’ incluye Xilinx® Synthesis Technology (XST), el cual sintetiza VHDL, Verilog, o diseños con mezcla de lenguajes para crear un fichero netlist específico de Xilinx conocido como fichero NGC.

El fichero NGC es un netlist que contiene datos de diseño lógico y restricciones. Este fichero reemplaza al EDIF y NCF.

Para hacer la siintesis nos vamos a la fuente “implementation” y seleccionamos “sumador (sumador.sch), y luego en la ventana de procesos seleccionamos synthesisze-xst.

10.Creando restricciones (.UCF).

Antes de realizar el ‘Translate’, vamos a crear un fichero de restricciones (.ucf) en el cual podremos asignar periodos y retardos de tiempo a los distintos elementos del diseño, así como asignar localizaciones de pin y configurar los IOB’s, los bloques de RAM, BUFG’s, y demás recursos del CPLD que hayan sido utilizados.

A continuación creamos el fichero (.ucf) situándonos en la fuente “implementation” y sobre el fichero (sumador.sch ), damos clic derecho y agregamos una nueva fuente “new source” y nos saldrá la ventana siguiente:

Seleccionando “implementation constraints file”, asignándole el nombre de “suma”.

Hacemos doble clic sobre el fichero (.ucf), y Asignamos los pines con PACE (Pin-out Area Constraints Editor), proceso asociado al fichero de restricciones “suma.ucf”.

En la tabla que se encuentra en la figura anterior es donde colocaremos los pines de entradas y salidas.

11.Translate.

Realiza todos los pasos necesarios para convertir los ficheros netlist de entrada, en un formato propietario NGD que utiliza una representación interna de la tecnología que se está empleando.

12.Fit.

El fit crea un mapa electrónico de la lógica definida por el fichero NGD dentro de los recursos del CPLD, tal como células lógicas, I/OB’s y otros componentes.

13.Generación del fichero (.JED).

Este fichero después de que haya sido generado se encuentra en la carpeta en la cual están todos los archivos del diseño. Además este fichero es el que vamos a descargar en la tarjeta “TAD-XC9572” mediante un interface de descarga llamado JTAG.

Para descargar el fichero (.JED), ES NECESARIO abrir el programa impact , este programa lo contiene el “ xilinx ISE”.

Abrimos el impact dando doble clic en “configure target device”.

Con todos los pasos hechos, cargamos el archivo (.JED), con el JTAG mediante cable usb a la tarjeta TAD-XC9572.

EJERCICIO Nº2

*Condiciones de respuestas de las salidas:

Led9 = Q3 /Q2 /Q1 Q0

Led8 = Q3 /Q2 /Q1 /Q0

Led7 = /Q3 Q2 Q1 Q0

Led6 = /Q3 Q2 Q1 /Q0

Led5 = /Q3 Q2 /Q1 Q0

Led4 = /Q3 Q2 /Q1 /Q0

Led3 = /Q3 /Q2 Q1 Q0

Led2 = /Q3 /Q2 Q1 /Q0

Led1 = /Q3 /Q2 /Q1 Q0

Led0 = /Q3 /Q2 /Q1 /Q0

Este ejercicio se va a emplear en el entorno de trabajo ISE XILINX el cual se va a diseñar el esquemático del contador de 4 bits y su decodificador.

Esquema:

En este esquema se puede observar el contador de 4 bits con sus entradas y salidas. Las salidas van conectadas al decodificador binario a decimal. Además contiene una puerta lógica and, sus entradas están conectadas a dos salidas (Q1 Y Q3) del contador y su salida conectada al clear de este. Su función es que cuando Q1 Y Q3 estén a “1” hace un borrado al contador inicializando su conteo desde el principio es decir a “0”.

El decodificador binario a decimal esta conectado mediante un bus a las cuatro salidas del contador de 4 bits. Y sus salidas irían a una barra de 10 leds lo cual mostrara la cuenta según el peso tal y como indica al tabla de verdad.

El tc que es el final de cuenta ira conectado al segmento “a” de un display 7 segmento, que cuando el led9 este a “1” este se encenderá indicando que ha pasado por este digito para volver al principio.

El clock conectado con al contador mediante un global buffer y CE (CHIP ENABLE) , debe permanecer a “1”, para darle permiso al contador de su cuenta.

SIMULACION POST-FIT:

En esta gráfica se puede visualizar el comportamiento exacto de las entradas y salidas del contador binario de 4 bits decodificado a decimal, además mediante esta simulación se puede ver los tiempos de respuestas que hay entre las distintas entradas con respecto al primer pulso del reloj.

Todo este contenido del esquemático ir dentro del cpld de xilinx XC9572 y sus pines de conexión serán los siguientes:

Como se puede observar cada entrada y salida que tiene el diseño del esquemático contiene unos pines indicados, el cual estos son los pines del XC9572 que se utilizaran para esta practica en la tarjeta TADXC9572.

EJERCICIO Nº3

La función de este ejercicio es aprender a crear un símbolo (decodificador BCD/7seg), a partir de un código vhdl.

Ahora bien hay que empezar a añadir símbolos en el esquemático en nuestro entorno de trabajo.

1-colocaremos un contador BCD llamado “CD4CE”.

2-un buffer global para el reloj llamado “BUFG”

3- un buffer global para el set/reset llamado “BUFGSR”.

4-un decodificador BCD/7 SEGMENTOS el cual se creara mediante el código vhdl.

5-siete buffer “OBUF” para los led’s que contiene el display 7 segmentos.

Diseñando el decodificador BCD/7 SEG.

Para diseñar el decodificador BCD-7SEG hay que transformar el código vhdl ,a un símbolo para que sea utilizado en el esquemático .

Lo primero es añadir una fuente tipo vhdl a nuestro diseño:

Luego de dar a ”next” saldrá otra ventana en donde finalizamos poniendo los puertos de la entidad, es decir un bus llamado ‘HEX’ de 4 entradas y otro bus de 7 salidas llamado ‘LED’.

El contenido de este fichero es una plantilla en la que se ha definido la entidad y falta por definir la arquitectura que describirá el funcionamiento funcional de la entidad.

A continuación buscaremos una plantilla para definir la arquitectura , para eso hay que ir a Edit en la opción —> Lenguage Templates, en la parte de VHDL/ Synthesis Constructs/Coding Examples/Misc/7-Segment display.

Esta plantilla es de un display 7 segmento de ánodo común y la que se necesita es de cátodo común así k hay que cambiar los “0” por “1” en la parte izquierda de la imagen y ya teniendo esta plantilla lo que hay que hacer es pegarla en el código que hemos generado anteriormente como se muestra a continuación:

Ya teniendo todo esto lo que nos queda es generar el símbolo del decodificador bcd/7seg para poder utilizarlo en el esquemático, y para eso desde el navegador de proyectos generamos nuestro símbolo.

Ya con el símbolo generado nos queda solamente conexionarlo a los demás símbolos dentro del esquemático.

Así estaría el esquema completo del contador BCD/7segmentos.

Se puede es analizar el diseño para ver su comportamiento con el simulate post-fit.

Hay que asignar los pines del cpld a los cual queremos que salga la información del contador bcd-7segmentos.

Para introducir esos pines desde XILINX hay que crear un fichero con la extensión “.ucf “, esto se hace añadiendo una fuente nueva en el proyecto como se indica a continuación.

Al tener el fichero (.ucf) solo haciendo doble clic sobre él nos aparecerá el “PACE” que es un programa que contiene xilinx para la asignación d pines para los cpld etc…

Luego de tener los pines asignados queda hacer los procesos finales para llevar el diseño por completo al cpld.

Los siguientes pasos son:

1-Sínthesize-xst.

2-Translate:

Realiza todos los pasos necesarios para convertir los ficheros netlist de entrada, en un formato propietario NGD que utiliza una representación interna de la tecnología que se está empleando.

3-fit:

Representa físicamente el conexionado de los componentes en el CPLD.

4-gemerate programing file:

El fit esta vinculado con este paso .Este nos genera el archivo que cargaremos la tarjeta TADXC9572 el cual tiene extensión (.JED) mediante el un cable HW-USB con el JTAG.

Terminado esto lo que queda es cargar el fichero(*.JED) a la tarjeta didáctica.

descargar archivo en pdf

EJERCICIO Nº4

Como dije anteriormente esta práctica se llevaría acabo mediante una maquina de estados tipo mealy, que será luego introducido en un símbolo grafico que se utilizara para el diseño en el esquemático.

TABLA DE ESTADOS:

Aquí se enumeran todos los estados posibles que tendrá la maquina de estados.

Estos estados no deben confundirse con los estados internos que se van a necesitar para registrar todo el proceso secuencial.

DIAGRAMA DE FLUJO:

Con este diagrama expresamos la secuencia del proceso de la maquina rotativa.

ENTORNO XILINX:

Una vez teniendo todo claro y sabiendo la secuencia de la máquina de estados, dibujaremos el esquemático en xilinx pero para eso hay que crear un símbolo del diagrama de estados del ejercicio, y para esto, xilinx tiene un entorno para crear diagramas de estados el cual se llama statecad.

En el statecad se puede simular los procesos de los estados paso a paso o si queremos hacerlo directamente sin ir paso a paso, lo que nos lleva a ver su comportamiento mediante una señal (statebench).

DIAGRAMA DE ESTADOS EN STATECAD:

Como he mencionado anteriormente con el statebench se puede crear una señal del comportamiento de la máquina rotativa, que a continuación se mostrara:

Luego hay que crear un código vhdl para poder crear el símbolo en el esquemático que a continuación se mostrará:

Luego de esto, en el área de trabajo de xilinx para crear el esquemático se añade una nueva fuente el cual es el archivo vhdl que se ha generado anteriormente y se crea un símbolo esquemático y así se obtendrá el símbolo de la maquina de estados.

Esquema:

Ya teniendo el esquemático completo, hace falta colocar los pines de entradas y salidas de la maquina rotativa al cpld.

Los puntos azules en la imagen son los pines asignados del cpld para la maquina rotativa.

Podemos observar el correcto funcionamiento del diseño en circuito con la siguiente configuración de entrada/salida:

ENTRADAS

RST = Estará en ‘0’ durante el proceso normal del autómata.
a, b = Pondremos una secuencia de valores que nos lleven por los distintos estados de la maquina.

CLK

SALIDA

M = Se pondrá en ‘1’ en los estados 1, 2, 3 y 4.

EJERCICIO Nº5

DIAGRAMA DE FLUJO:

Ahora se irá al entorno xilinx (statecad) para empezar a diseñar el diagrama de flujo tipo moore.

Luego de tener diseñado el diagrama de estados del detector de secuencia, se genera una señal para ver el comportamiento de la entrada y la salida con respecto a los ciclos del reloj en cada estado (statebench).

Después de darle a “automatic testbench”, se puede observar en la señal la salida “s” esta puesta a “1” dos veces, es porque en la entrada se ha puesto el código de secuencia dos veces durante los ciclos del reloj.

Una vez teniendo esto en cuenta, se genera el código vhdl:

Ahora es añadir el fichero vhdl que se ha creado al proyecto en el entorno xilinx.

En esta grafica se muestra el código vhdl del detector de secuencia , además se ven los archivos (*.ucf =para colocar los pines en el cpld, y *.dia=diagrama de estados del detector de secuencia).

Ahora se mostraran los pines para las entradas y salida del detector de secuencia asociados con el cpld.

Y ya con los pines colocados ahora se generan los demás pasos para poder cargar dicho diseño en el cpld XC9572.

Como se puede observar en la imagen cada paso que hay que hacer para poder generar el fichero de descarga hacia la tarjeta TAD-XC9572 están en verde, lo que quiere decir que se han completado correctamente y finalmente podemos descargar el diseño de la maquina de estados en el cpld XC9572, solo hay que buscar el fichero de descarga y abrir el impact para poder enviarlo mediante el jtag a la tarjeta de aplicación didáctica.

EJERCICIO Nº6

Modo de trabajo:

1. Secuencia de inicio.

2. Enviar instrucción de ‘Pantalla ON/OFF’ de manera que ponemos la pantalla en ON ‘D=1’, el cursor en ON

‘C=1’ y el parpadeo del cursor en ON ‘B=1’.

3. Colocar el cursor en la posición de inicio con la instrucción ‘Cursor a casa’.

4. Mandar los datos de la primera línea.

5. Cambiar de línea.

6. Mandar los datos de la segunda línea.

La máquina va a necesitar de dos contadores, uno de 3 bit’s y otro de 5 bit’s, a modo de flag, en este caso como no hay contadores de 5 bit’s en xilinx utilizaremos uno de 8bit’s.

Hay que tener en cuenta que el LCD está conectado directamente al Banco 2 del CPLD, lo que nos llevará a especificar los pines manualmente.

Ahora bien teniendo en cuenta esto, nos dirigimos al entorno xilinx y en el statecad se va a diseñar el diagrama de estados para luego crear su símbolo en el esquemático y escribir en el lcd.

Lo primero que hay que hacer en el statecad es añadir los puertos de entradas y salidas de la maquina de estados.

AÑADIENDO PUERTOS DE ENTRADAS Y SALIDAS.

El autómata tiene que controlar el LCD y para ello necesitará los siguientes puertos:

RS = Salida.- Control de selección de modo.

Habilitar = Salida.- Habilitación del módulo.

read_write = Salida.- Control de lectura/escritura en el módulo.

Las líneas D0-D7 del LCD son bidireccionales por lo que en el autómata tendremos ‘Dx’ de entrada y de salida.

D0_O, D1_O, D2_O, D3_O, D4_O, D5_O, D6_O, D7_O = Salida

D0_I, D1_I, D2_I, D3_I, D4_I, D5_I, D6_I, D7_I = Entrada

three_state ->Salida

Analizando el proceso de trabajo y teniendo en cuenta el nº de caracteres a visualizar, incluyendo los espacios, al LCD tenemos que mandarle 6 comandos y 24 datos.

Para los comandos utilizaremos un contador de 3 bits y para los datos el de 8 bits porque en el entorno xilinx no hay símbolos de contadores de 5 bits.

Puertos de control de los contadores:

q0_r, q1_r, q2_r = Entradas.- Entradas de control del nº de comandos o registros mandados al LCD.

q0_d, q1_d, q2_d, q3_d, q4_d = Entradas.- Entradas de control del nº de datos mandados al LCD.

puesta_0 = Salida.- Salida de inicialización de los contadores.

reloj_dato = Salida.- Reloj del contador de datos.

reloj_registro = Salida.- Reloj del contador de comandos.

Ahora teniendo todo esto en cuenta, se irán añadiendo todos los puertos de entradas y salidas en el statecad para el diagrama de estados.

Secuencia del programa:

El autómata tiene que resolvernos el proceso de trabajo por lo que su diseño lo vamos a dividir en las distintas etapas del propio proceso.

1º.- Secuencia de inicio.

2º.- Enviar instrucción de ‘Pantalla ON/OFF’ de manera que ponemos la pantalla en ON ‘D=1’, el cursor en ON ‘C=1’ y el parpadeo del cursor en ON ‘B=1’.

3º.- Colocar el cursor en la posición de inicio con la instrucción ‘Cursor a casa’.

4º.- Mandar los datos de la primera línea.

5º.- Cambiar de línea.

6º.- Mandar los datos de la segunda línea.

*La secuencia de inicio esta compuesta en el diagrama de estado por los siguientes estados:

State 0:

En este estado la salida ‘three_state’ la hemos puesto a ‘0’, lo

que significa que sube a ‘1’ por trabajar en bajo activo. De esta

forma, el diseño pone las salidas del autómata ‘Dx_O’ en estado

de alta impedancia.

Transiciones: Al STATE1 sin condiciones.

State 1:

Ponemos la salida ‘reloj_registro’ a ‘1’ para aumentar la cuenta en el contador de comandos.

Transiciones: Al STATE2 sin condiciones

State 2:

Habilitamos el LCD y lo ponemos en modo de lectura, así podremos leer el flag ‘BUSY’ para saber si está ocupado.

Transiciones: Al STATE3 sin condiciones.

State 3:

Mantenemos las salidas anteriores y nos quedamos en este estado hasta que el LCD deje de estar ocupado.

Transiciones: Al STATE4 si ‘D7_I=0’

State 4:

Deshabilitamos el LCD y nos vamos al estado 5, para mandar el comando de inicio.

Transiciones: Al STATE5 si [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′]

State 5:

Habilitamos el LCD y dejamos las señales ‘Dx_O’ del autómata comunicadas al puerto ‘Dx’ del LCD, todo ello para mandar el código de la condición de inicio ‘00111000’. Por este estado pasaremos 3 veces.

Transiciones: Al STATE9 sin condiciones.

state 9:

Si no hemos terminado de mandar los códigos de la condición de inicio volvemos al estado 0.

Transiciones: Al STATE0 si [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′]

*Ahora pasamos a las instrucciones de pantalla “on/off”.

Vamos a mandar uno que deje la pantalla en ON ‘D=1’, el cursor en ON ‘C=1’ y el parpadeo del cursor en ON ‘B=1’.

Para ello, añadimos un nuevo estado al diagrama (State6).

State 4:

Añadimos la transición al estado 6 con la condición [Q0_R=’0′ & Q1_R=’0′ & Q2_R=’1′]

Transiciones: Al STATE5 si [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′]

al STATE6 si [Q0_R=’0′ & Q1_R=’0′ & Q2_R=’1′]

Habilitamos el LCD y dejamos las señales ‘Dx_O’ del autómata comunicadas al puerto ‘Dx’ del LCD, todo ello para mandar el código de ‘Pantalla ON/OFF’ ‘00001111’.

Transiciones: Al STATE9 sin condiciones

*Instrucciones para poner el cursor a casa

Durante esta instrucción se envía el cursor en la posición de inicio de la pantalla.

Para esto se añade el state 7.

State 4:

Transiciones al state 7: si [Q0_R=’1′ & Q1_R=’0′ & Q2_R=’1′]

State 7:

Habilitamos el LCD y dejamos las señales ‘Dx_O’ del autómata comunicadas al puerto ‘Dx’ del LCD, todo ello para mandar el código de ‘cursor a casa’ ‘00000010’.

Transiciones: Al STATE9 sin condiciones

State 9:

Transiciones: Al STATE0 si [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′] ó [Q0_R=’0′ & Q1_R=’0′ & Q2_R=’1′]

al STATE10 si [Q0_R=’1′ & Q1_R=’0′ & Q2_R=’1′]

*Instrucciones para enviar datos a la primera linea.

Los estados que se van a añadir acontinuacion para enviar escribir los datos en la primera linea son del state 14 al state 29.

Ponemos las salida ‘reloj_dato’ a ‘1’ para aumentar la cuenta en el contador de datos. Las demás salidas, al no ser contempladas, quedan todas a nivel ’0’.

Transiciones: Al STATE11 sin condiciones.

State 11:

Habilitamos el LCD y lo ponemos en modo de lectura, así podremos leer el flag ‘BUSY’ para saber si está ocupado.

Transiciones: Al STATE12 sin condiciones.

State 12:

Mantenemos las salidas anteriores y nos quedamos en este estado hasta que el LCD deje de estar ocupado.

Transiciones: Al STATE13 si ‘D7_I=0’

State 13:

Ponemos el LCD en modo ‘dato’ y pasamos a los distintos estados que contienen cada uno de los 16 caracteres de la primera línea, dependiendo de cómo se encuentre el contador de datos.

Transiciones: 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′]

A continuación se mostraran los caracteres de la primera línea que hay en cada estado desde el 14 hasta el 29. Estos caracteres son buscados mediante su código ascii y luego hay que convertir el valor numérico de su código en binario para poder introducirlo en el estado por ejemplo:

A=65 ——>1000001 ——-el bit de mayor peso corresponde al D6 y el de menor peso corresponde a D0, es decir vendría siendo algo como: D6=1, D5=0, D4=0, D3=0, D2=0, D1=0, D0=1, para poder introducir la A en un estado y visualizarla en el lcd.

Transiciones: Al STATE38 sin condiciones.

State 38:

Transiciones: Al STATE39 sin condiciones.

State 39:

Deshabilitamos el LCD y pasamos al estado 10 hasta introducir los 16 caracteres en el LCD. Una vez hecho esto, pasamos al estado 0 para cambiar de línea mandando un nuevo comando.

Transiciones: Al STATE10 si [Q0_D=’1′ & Q1_D=’0′ & Q2_D=’0′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’1′ & Q2_D=’0′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’1′ & Q2_D=’0′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’0′ & Q2_D=’1′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’0′ & Q2_D=’1′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’1′ & Q2_D=’1′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’1′ & Q2_D=’1′ & Q3_D=’0′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’0′ & Q2_D=’0′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’0′ & Q2_D=’0′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’1′ & Q2_D=’0′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’1′ & Q2_D=’0′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’0′ & Q2_D=’1′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’1’ & Q1_D=’0′ & Q2_D=’1′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’0′ & Q1_D=’1′ & Q2_D=’1′ & Q3_D=’1′ & Q4_D=’0′] ó

[Q0_D=’1′ & Q1_D=’1′ & Q2_D=’1′ & Q3_D=’1′ & Q4_D=’0′] ó

al STATE0 si [Q0_D=’0′ & Q1_D=’0′ & Q2_D=’0′ & Q3_D=’0′ & Q4_D=’1′]

*Instrucciones para cambiar de linea.

Tras el comando ‘mandar los datos de la 1ª línea’, mandamos el comando ‘dirección DDRAM’ con el código ‘11000000’ consiguiendo, con ello, que el cursor se coloque en la 1ª posición de la segunda línea.

Se añade el estado 8 en el conjunto del diagrama.

State 4:

Añadimos la transición al estado 8 con la condición [Q0_R=’0′ & Q1_R=’1′ & Q2_R=’1′]. Además, por seguridad, añadimos una transición al estado 40 desde donde reiniciaremos la cuenta de los contadores en el caso de que se pierda el control del flujo del autómata.

Transiciones:

Al STATE8 si [Q0_R=’0′ & Q1_R=’1′ & Q2_R=’1′]

Al STATE40 si no se cumple ninguna de las condiciones anteriores (else).

State 8:

Habilitamos el LCD y dejamos las señales ‘Dx_O’ del autómata comunicadas al puerto ‘Dx’ del LCD, todo ello para mandar el código de ‘dirección DDRAM’ ‘11000000’.

Transiciones: Al STATE9 sin condiciones

State 40:

Desde este estado reiniciamos la cuenta de los contadores y volvemos al estado 0 para comenzar de nuevo la visualización. Aquí solo se caerá en el caso de perder el control del flujo del autómata.

Transiciones: Al STATE0 sin condiciones.

*Instrucciones para mandar datos a la 2da linea.

En esta parte se añaden los estados 30 hata el 37 , el cual se van a escribir los datos de la segunda línea .

State 13:

Ponemos el LCD en modo ‘dato’ y pasamos a los distintos estados que contienen cada uno de los 8 caracteres de la segunda línea, dependiendo de cómo se encuentre el contador de datos.