VERANO DE LA INVESTIGACIÓN CIENTÍFICA 2007

Marina Betancourt Robles

Asesor
Dr. Madaín Pérez Patricio

Instituto Tecnológico de Tuxtla Gutiérrez

ACERCA DEL SOFTWARE

Para la programación en VHDL que estamos realizando, necesitamos un

conocimiento básico acerca del software Quartus II, el cual se utilizará por ser
compatible y por venir integrado como parte del quit que actualmente se posee
y en el cual se están realizando las pruebas pertinentes.

Básicamente tocaremos 5 puntos en cuanto al uso del software:

a) Como crear proyectos y escribir nuestros archivos en el editor de
Quartus
b) Como Compilar el Proyecto y observar los resultados
c) Como realizar simulaciones
d) Hacer la asignación de pines hacia el dispositivo (FPGA)
e) Cargar el programa en el dispositivo

CREAR PROYECTOS Y EL EDITOR DE TEXTO

Para esto iniciamos el Quartus II y observaremos la siguiente pantalla

En el menú Archivo seleccionamos la opción Asistente para Nuevo Proyecto y

seguimos las instrucciones:
Dentro del Asistente seleccionamos la carpeta donde se colocará el proyecto
así como el nombre del proyecto y el nombre de la entidad principal. Si la
carpeta no existe, el programa la crea automáticamente.

Si tenemos archivos ya creados (archivos que deban formar parte del proyecto)
podemos agregarlo pero generalmente se omite agregar archivos en este paso.
Asi que solo tecleamos “siguiente” cuando observemos la siguiente ventana.
En la selección del dispositivo recordamos que estamos utilizando un FPGA de
la familia Cyclone II, específicamente el EP2C235F672C6.

En el siguiente paso, debemos tener en cuenta que utilizaremos todas las

herramientas mencionadas, así que habilitamos las tres opciones
Aquí podemos ir a la siguiente opción para ver la síntesis de los datos que se
dieron para la creación del proyecto y teclear “Finalizar”. Una vez creado el
proyecto, obtendremos observamos que ya se tiene un archivo base para
trabajar.

Para crear un archivo de tipo VHDL solo basta con seleccionar Nuevo de la
barra de tareas y elegir la opción “Archivo VHDL”.

Veremos el editor de texto desde donde es posible comenzar a escribir los

programas.
COMPILACIÓN DEL PROYECTO

Una vez que se tiene escrito el programa y el proyecto listo solo es necesario
dar clic en el botón de “Comenzar compilación” .
Durante el proceso observaremos en la parte inferior de la pantalla una serie de
mensajes que indican las operaciones realizadas, los errores ocurridos y
comentarios a considerar. Una vez que la compilación finaliza de manera
exitosa, Quartus II muestra un mensaje como el mostrado en la pantalla
anterior, en caso contrario el mensaje de error indica la posible causa y es
necesario hacer las correcciones pertinentes.

SIMULACIÓN DE PROYECTOS

Para realizar una simulación es necesario tener un archivo llamado “Vector de

formas de onda” y a partir de el se obtienen las salidas que da el circuito
implementado a partir de las entradas que se le proporcionan. Para ello se
elige Nuevo del menú Archivo y en el cuadro de diálogo que se abre
seleccionamos la pestaña “Otros archivos” y finalmente la opción Vector de
formas de onda. Una vez abierto es importante guardarlo para poder hacer
referencia a el posteriormente.

edatools

Una vez abierto el editor se observa una pantalla desde donde podemos
agregar las entradas y las salidas (las salidas las genera el simulador, el
usuario solo proporciona las entradas). Para ello se da Clic derecho sobre la
parte izquierda del editor tal como se ve en la imagen y se elige la opción
“Insertar nodos”. Al abrirse el siguiente cuadro de diálogo es posible utilizar la
opción “Buscador de Nodos” y facilitar el trabajo:
El buscador es una herramienta que permite agregar todas las entradas y
salidas que deseemos, pues a partir del proyecto realizado localiza y despliega
todos los puertos declarados, desplegándolos en una lista desde la que
fácilmente se agregan aquellos que serán útiles para la simulación.

El siguiente paso después de Aceptar los cambios, es asignar este archivo al

simulador, por lo se puede seleccionar la opción “Settings” del menú
“Assignments” y en el cuadro de texto donde se escribe el nombre del archivo
que contiene las entradas para simulación se coloca la ruta del archivo .wvf que
se guardó con anterioridad.

Una vez realizado esto, se comienza con la simulación dando clic en el botón
“Comenzar simulación”.

Si la simulación se termina de manera aceptable, el programa manda un

mensaje indicando que se obtuvieron resultados exitosos y despliega las
salidas obtenidas para el programa escrito.
ASIGNACIÓN DE PINES

El software cuenta con un plano de pines el cual despliega todos los puertos
del dispositivo seleccionado a la hora de crear el proyecto. Para tener acceso a
el solo basta con seleccionar la opción mostrada en la figura:
Se muestra inmediatamente la siguiente pantalla desde la cual se asignan las
entradas y las salidas a los pines correspondientes. En este caso en particular
y debido a que se está haciendo uso de un quit, es necesario consultar el
manual para poder hacer una correcta asignación de puertos.

PROGRAMACIÓN DEL DISPOSITIVO

Para realizar la programación del FPGA es necesario utilizar el programador
que viene junto con el Quartus II. Para ello se selecciona desde la barra de
tareas el botón “Programador”. Recordando que el quit debe estar conectado,
encendido y en modo RUN.

Una vez que esta pantalla es visualizada, ejecutamos el comando Guardar

como, del menú archivo, para asignarle un nombre conveniente.

Lo único que es necesrio para que el dispositivo sea programado es activar la

casilla “Program / Configure” y que el Hardware detectado sea correcto y
aparezca en el cuadro de texto con leyenda “Hardware Setup”. Teniendo esto
se pulsa el botón etiquetado como “Start".

ACERCA DEL LENGUAJE

Para programar este dispositivo es necesario utilizar un lenguaje de descripción

de hardware (HDL). Dentro de los lenguajes que existen de este tipo, se ha
elegido el VHDL por ser compatible con el software que se posee y con el
dispositivo. A continuación el documento se enfoca en la tarea básica de
conocer algunas de las capacidades del FPGA y su programación en VHDL,
además de la interacción completa con el software y la carga del Programa al
dispositivo para la comprobación de su funcionamiento. El plan de trabajo que
se pretende seguir es el siguiente:

a) Utilización de los displays de 7 segmentos.

b) Utilización de la pantalla LCD monocromática de 16X2.
 c) Utilización de una cámara digital para obtener información para uso
posterior de una LCM para despliegue de esa información.
d) Implementación de una red neuronal.

INTRODUCCIÓN A LA PROGRAMACIÓN EN LENGUAJE VHDL

Lenguaje de descripción de hardware (HDL) es el acrónimo de Hardware

Description Language (Lenguaje de Descripción de Hardware). Son lenguajes
de programación en los que el objetivo es programar un circuito electrónico. El
flujo de diseño suele ser típico:

 Definir la tarea o tareas que tiene que hacer el circuito.

 Escribir el programa usando un lenguaje HDL. También existen programas
de captura de esquemas que pueden hacer esto, pero no son útiles para
diseños complicados.
 Comprobación de la sintaxis y simulación del programa.
 Programación del dispositivo y comprobación del funcionamiento.

Un rasgo común a estos lenguajes suele ser la independencia del hardware y

la jerarquía, es decir, una vez hecho un diseño éste puede ser usado
dentro de otro diseño más complicado y con otro dispositivo compatible. El
leguaje VHDL es un lenguaje basado en HDL (existen otros como el

Verilog o el ABEL HDL).

VHDL es el acrónimo que representa la combinación de VHSIC y

HDL, donde VHSIC es el acrónimo de Very High Speed Integrated

Circuit y HDL es a su vez el acrónimo de Hardware Description Language.

Es un lenguaje usado por ingenieros definido por elIEEE

(Institute of Electrical and Electronics Engineers) (ANSI/IEEE 1076-1993)

que se usa para diseñar circuitos digitales. Aunque

puede ser usado de forma general para describir cualquier circuito se usa

principalmente para programar PLD (Programable Logic Device -

Dispositivo Lógico Programable), FPGA (Field Programmable Gate

Array), ASIC y similares.

Descripción de pines de fpga-soc

CONOCIENDO EL LENGUAJE VHDL

El lenguaje VHDL está creado específicamente para el diseño de hardware, es

decir, podremos implementar con él multitud de circuitos lógicos, tanto
combinacionales como secuenciales. Éste lenguaje también nos permite
describir elementos más complejos, como CPU's (Unidad Central de
Procesamiento), manejar ficheros, retrasos en el tiempo, etc.

Un programa en VHDL consta de dos partes:

a) La entidad, en esta parte solo especificamos las entradas y las salidas,
como si se tratara de una caja negra y solo definimos el exterior.
b) La arquitectura, describe como trata el circuito la información
correspondiente a las entradas para obtener las salidas.

VHDL ha sido construido para soportar las siguientes funciones lógicas: AND,
OR, NOT, NAND, NOR, XNOR y XNOR. El operador básico para asignación en
este lenguaje es <=, y es necesario recalcar que no reconoce precedencia de
operadores esto implica que una sentencia como

f<=x1 AND x2 OR NOT x2 AND x3

deba escribirse como

f<=(x1 AND x2) OR ((NOT x2) AND x3)

si deseamos que se respete la precedencia usual de los operadores.

DECLARACION DE UNA ENTIDAD

La sintaxis básica para la declaración de una entidad es la siguiente:

entity nombre_entidad is
port(
-- puertos de entradas
nombre_puerto: modo tipo;
-- puertos de salidas
nombre_puerto: modo tipo;
-- puertos de I/O
nombre_puerto: modo tipo;
-- puertos de buffers
nombre_puerto: modo tipo;
);
end nombre_entidad;

Todo aquello seguido presedido de ‘--' es un comentario y es ignorado por el

compilador. Los modos en que se pueden configurar los puertos son:

Modo in: Un puerto es de modo in si la información correspondiente al mismo,

entra a la entidad y se suele usar para relojes, entradas de control (como las
típicas load, reset y enable), y para datos de entrada unidireccionales.

Modo out: Un puerto es de modo out si la información fluye hacia fuera de la

entidad. Este modo no permite realimentación ya que al declarar un puerto
como out estamos indicando al compilador que el estado lógico en el que se
encuentra no es leíble.

Modo buffer: Es usado para una realimentación interna ,es decir, para usar este
puerto como un driver dentro de la entidad. Este modo es similar al modo out,
pero además, permite la realimentación y no es bidireccional, y solo puede ser
conectado directamente a una señal interna, o a un puerto de modo buffer de
otra entidad. Una aplicación muy común de este modo es la de salida de un
contador, ya que debemos saber la salida en el momento actual para
determinar a salida en el momento siguiente.
Modo inout: Es usado para señales bidireccionales, es decir, si necesitamos
que por el mismo puerto fluya información tanto hacia dentro como hacia afuera
de la entidad. Este modo permite la realimentación interna y puede reemplazar
a cualquiera de los modos anteriores, pudiéndose usar este modo para todos
los puertos, pero reduciremos la lectura posterior del código por otra persona, y
reduciendo los recursos disponibles de la dispositivo.

En cuanto a los tipos VHDL incorpora varios tipos de forma estándar pudiendo
usar otros definidos en librerías normalizadas, y las creados por el usuario. La
norma internacional IEEE 1076/93 define cuatro tipos nativos para VHDL como
son:

Tipo boolean: puede tomar dos valores: verdadero/true o falso/false. Un

ejemplo típico es la salida de un comparador que da verdadero si los números
comparados son iguales y falso si no lo son:
Tipo bit: Puede tomar dos valores: 0 ó 1 (o también "low" o "high", según se
prefiera). Es el tipo más usado de los nativos.

Tipo bit_vector: Es un vector de bits. Ejemplo:

En este caso el MSB es numero(0) y
numero : bit_vector (0 to 7);
numero(7) el LSB
En este caso el MSB es numero(7) y
numero : bit_vector (7 downto 0);
numero(0) el LSB

Tipo integer: Para manejar números enteros.

Tipo std_logic, std_ulogic, y sus derivados tales como std_logic_vector y

std_ulogic_vector. Como su nombre pretende indicar, es el tipo de tipo lógico
estándar, que es el más usado en la actualidad, así como en la mayoría de
ejemplos de este libro.

En cuanto a reglas de sintaxis, se recalca que VHDL no distingue las letras

mayúsculas de las minúsculas y el primer carácter de un puerto sólo puede ser
una letra, nunca un número. Así mismo, no pueden contener caracteres
especiales como $, %, ^, @, etc. y dos caracteres de subrayado seguidos.

Ejemplo:

entity vocal is
port(
-- puertos de entrada
entrada: in bit_vector(2 downto 0);
-- puertos de salida
salida: out bit_vector(6 downto 0)
);
end vocal;

DECLARACION DE UNA ARQUITECTURA

En la arquitectura se define el proceso que se le dará a las señales de entrada

para obtener las salidas. Si la entidad es vista como una "caja negra", la
arquitectura es el conjunto de detalles interiores de la caja negra. La
declaración de arquitecturas debe constar de las siguientes partes:

architecture nombre_arquitectura of nombre_entidad is

--señales
begin
--nucleo del programa, Conjunto de sentencias, bucles, procesos, funciones
--que dan operatividad al programa.
end nombre_arquitectura;

Para describir una arquitectura podremos usar cuatro estilos, teniendo cada
uno, su propio nivel de abstracción:
Estilo comportamental: Este estilo se caracteriza por incluir las sentencias y
órdenes típicas de un lenguaje de programación (if, then, case,...), sin
importarnos como quedará la distribución de puertas lógicas dentro del
dispositivo.

Estilo dataflow o flujo de datos: Indican cómo la información será transferida a

la salida sin el uso de asignaciones secuenciales, es decir, en este estilo no se
pueden usar los procesos. Ejemplos de núcleos del programa para la
arquitectura podrían ser los siguientes:

a) SALIDA<='1' when (a=b) else '0';

b) SALIDA<= not(a(0) xor b(0)) and not(a(1) xor b(1)) and not(a(2) xor b(2))
and not(a(3) xor b(3));

Estilo estructural: En él se describe un "netlist" de VHDL, en los cuales los

componentes son conectados y evaluados instantáneamente mediante
señales. Ejemplo:
 u0: xnor2 port map (a(0),b(0),x(0));
u1: xnor2 port map (a(1),b(1),x(1));
u2: xnor2 port map (a(2),b(2),x(2));
u3: xnor2 port map (a(3),b(3),x(3));
u4: and4 port map (x(0),x(1),x(2),x(3),igual);
Hasta aquí se esta listo para implemetar programas básicos con el manejo de
los displays de 7 segmentos, para después pasar a temas de mayor grado de
complejidad que nos permitan hacer uso de la LCD.

Descripción estructural

Compuertas

entity helloworld is

port(

-- puertos de entrada

entrada: in bit_vector(1 downto 0);

-- puertos de salida

salida: out bit_vector(1 downto 0)

);

end helloworld;
architecture hola of helloworld is

--señales

begin

salida(0) <= (not(entrada(0)) and not(entrada(1))) or (entrada(0) and entrada(1));

salida(1) <= entrada(0) or entrada(1);

end hola;

Multiplexor
Sea la siguiente tabla de verdad para un multiplexor de un bit

sel a b Salida
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 0
1 1 1 1
Salida=sel’ab’+sel’ab+sela’b+selab
Salida=sel’a+selb
El código VHDL es el siguiente

entity multiplexor is

port(

-- puertos de entrada

entrada: in bit_vector(1 downto 0);

sel: in bit;

-- puertos de salida

--salida: out bit_vector(1 downto 0)

salida: out bit

);

end multiplexor;
architecture hola of multiplexor is

--señales

begin

salida <= (entrada(0) and sel) or (entrada(1) and not sel);

end hola;

Descripción comportamental
Dado que vhdl es un lenguaje de alto nivel, es posible describir los circuitos de acuerdo
a su funcionamiento.
entity helloworld is

port(

-- puertos de entrada

entrada: in bit_vector(1 downto 0);

sel: in bit;

-- puertos de salida

--salida: out bit_vector(1 downto 0)

salida: out bit

);

end helloworld;

architecture hola of helloworld is

--señales

begin

process (entrada,sel)

begin

if sel='0' then

salida <= entrada(0);

else
 salida <= entrada(1);

end if;

end process;

end hola;

EJEMPLO 1
UTILIZACION DE LOS DISPLAYS DE 7 SEGMENTOS

DESPLIEGUE BASICO

Plantemaiento del problema:

Realizar un programa que desplique la letra A en un display de siete

segmentos utilizando lógica negativa y considerando que no hay entradas al
dispositivo.

Propuesta de solución:

Considerando que el orden de los segmentos del display sea el siguiente.

Hacemos tenemos que la salida buscada implica encender todos los

segmentos excepto el d:
Salida <= "0001000"
Teniendo esto, nuestro programa en VDHL seria el siguiente:

library ieee;
use ieee.std_logic_1164.all;

entity display is
port(
salida: out bit_vector(6 downto 0)
);
end display;

architecture segmentos of display is

--señales
begin
salida <= "0001000";
end segmentos;

EJEMPLO 2
UTILIZACION DE LOS DISPLAYS DE 7 SEGMENTOS

CODIFICADOR DE BINARIO A 7 SEGMENTOS

MENSAJE: A E I O U

Planteamiento del problema:

Realizar un programa que desplique las vocales se modo que lea la entrada y
para una entrada igual a un 0 decimal, despliegue la A, para una entrada igual
a un 1 decimal despliegue la E, si la entrada recibe un 3 decimal desplegará
una I y asi sucesivamente hasta llegar al 5 o a la U.

Propuesta de solución:

Considerando que el orden de los segmentos del display sea el siguiente.

y que se forman todas las letras deseadas a partir de estos segmentos (un
segmento enciende con un 1 lógico aplicado a la pata correspondiente), se
obtiene la siguiente tabla de verdad:

Letra que Entrada en Entrada Salida en formato decimal

se desea formato binario en (Los bits de salida se corresponden
formar formato con los segmentos del Display)
X1 X2 X3 decimal a b c d e f g
A 0 0 0 0 1 1 1 0 1 1 1
E 0 0 1 1 1 0 0 1 1 1 1
I 0 1 0 2 0 1 1 0 0 0 0
O 0 1 1 3 1 1 1 1 1 1 0
U 1 0 0 4 0 1 1 1 1 1 0
NINGUNA x x x 5 x x x x x x x
NINGUNA x x x 6 x x x x x x x
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
Nota: el simbolo ‘x’ en la tabla indica ‘Don’t care’ o sin importancia
Con esta tabla de verdad podemos programar el despliegue de las letras en
lenguaje VHDL de dos maneras: utilizando directamente la tabla o convirtiendo
los resultados de salida para cada segmento en funciones lógicas. Para
obtener estas funciones podemos usar mapas de Karnaugh. Por ejemplo, para
el segmento a tendríamos:

Segmento a = X3+X1’X2’

Esta operación podría repetirse para todos los segmentos y tendriamos una
equación para cada uno.

El programa en VDHL utilizando funciones lógicas (solo se ejemplifica para el

segmento a) quedaría como sigue:

library ieee;
use ieee.std_logic_1164.all;

entity vocal is
port(
-- puertos de entrada
x1: in bit;
x2: in bit;
x3: in bit;
-- puertos de salida
a: out bit;
);
end vocal;

architecture despliegue of vocal is

--señales
begin
--nucleo del programa
a<=x3 or ((not x1) and (not x2))
-- se escribirían ecuaciones diferentes para cada segmento
end despliegue;

El programa en VHDL utilizando la tabla de verdad quedaría como sigue:

library ieee;
use ieee.std_logic_1164.all;
entity vocal is
port(
-- puertos de entrada
entrada: in bit_vector(2 downto 0);
-- puertos de salida
salida: out bit_vector(6 downto 0)
);
end vocal;

architecture despliegue of vocal is

--señales
begin
proceso: process(entrada)
begin
case entrada is
when "000" => salida <= "0001000";
when "001" => salida <= "0110000";
when "010" => salida <= "1001111";
when "011" => salida <= "0000001";
when "100" => salida <= "1000001";
when others => salida <= "1111111";
end case;
end process proceso;
end despliegue;

LOS COMPONENTES EN VHDL

Los componentes tienen la misma estructura que una entidad con su propia
arquitectura, por ello una entidad declarada en alguna parte del diseño o en
alguna biblioteca se puede enlazar con la entidad principal del programa
(debemos aclarar que la entidad principal debe llevar el mismo nombre que el
proyecto para que el programa lo considere a la hora de compilar).

Para utilizar un componente es necesario copiarlo en la arquitectura tantas

veces como se necesite antecedido por un nombre que se dará a esa copia
particular de la referencia.

Veamos un ejemplo: suponiendo que deseamos realizar la descripción

estructural del siguiente circuito utilizando componentes:
-- Lo primero de todo es la definición de las entidades y sus
-- arquitecturas. Esto se podría poner en un fichero aparte o
-- definirlo dentro de una biblioteca:

ENTITY inv IS PORT (e: IN bit; y: OUT bit); END inv;

ENTITY and2 IS PORT (e1,e2: IN bit; y: OUT bit); END and2;
ENTITY or2 IS PORT (e1,e2: IN bit; y: OUT bit); END or2;

ARCHITECTURE rtl OF inv IS BEGIN y<=NOT e; END rtl;

ARCHITECTURE rtl OF or2 IS BEGIN y<=e1 OR e2; END rtl;
ARCHITECTURE rtla OF and2 IS BEGIN y<=e1 AND e2; END rtla;
ARCHITECTURE rtlb OF and2 IS -- dos arquitecturas diferentes
BEGIN
y<='0' WHEN (e1='0' OR e2='0') ELSE '1';
END rtlb;

-- A continuación ya viene la entidad y arquitectura del mux:

ENTITY mux IS
PORT ( a,b,selec: IN bit;
salida: OUT bit);
END mux;

ARCHITECTURE estructura OF mux IS

COMPONENT inv IS PORT(e: IN bit; y: OUT bit); END COMPONENT;
COMPONENT y2 IS PORT(e1,e2: IN bit; y: OUT bit); END COMPONENT;
COMPONENT o2 IS PORT(e1,e2: IN bit; y: OUT bit); END COMPONENT;
SIGNAL ax,bx,nosel: bit;
BEGIN
u0: inv PORT MAP(e=>selec,y=>nosel);
u1: y2 PORT MAP(e1=>a,e2=>nosel,y=>ax);
u2: y2 PORT MAP(b,selec,bx);
u3: o2 PORT MAP(e1=>ax,e2=>bx,y=>salida);
END estructura;
-- Por último, la configuración sería:

CONFIGURATION estru OF mux IS

-- poniendo USE work.ALL; aquí, no haría falta poner 'work' cada vez.
FOR estructura
FOR ALL: inv USE ENTITY work.inv; END FOR;
FOR u1: y2 USE ENTITY work.and2(rtla); END FOR;
FOR OTHERS: y2 USE ENTITY work.and2(rtlb); END FOR;
FOR ALL: o2 USE ENTITY work.or2; END FOR;
END FOR;
END estru;

LIBRERIAS LPM (LIBRARY OF PARAMETERIZED MODULES)

En este punto es posible comenzar a trabajar con las librerías que tenemos
incluidas en el software que estamos utilizando, entre ellas esta la librería LPM
(library of parameterized modules) que contiene funciones parametrizadas que
podemos incluir en nuestros programas. Podriamos realizar conexiones
sencillas agregando como componentes algunas comPuertas para despues
indicar conexiones entre ellas dentro de la arquitectura de alguna entidad o
hacer algunas aplicaciones mucho mas complicadas, todo dependerá del
diseño que queramos implementar y de la habilidad del programador.

Además de las funciones LPM existen más funciones parametrizadas, la

declararación del componente, asi como sus parámetros e información
relacionada esta disponible en la ayuda del Quartus II. Se incluirá solo la lista
con todas las funciones disponibles en la librería.

Arithmetic
Components
altaccumulate divide*
altfp_add_sub lpm_abs
altfp_mult lpm_add_sub
altmemmult lpm_compare
altmult_accum lpm_counter
altmult_add lpm_divide
altsqrt lpm_mult
altsquare parallel_add

Gates
busmux lpm_inv
lpm_and lpm_mux
lpm_bustri lpm_or
lpm_clshift lpm_xor
lpm_constant mux
lpm_decode
I/O Components
alt2gxb altdqs
alt2gxb_reconfig altgxb
altasmi_parallel altlvds_rx
altcdr_rx altlvds_tx
altcdr_tx altpll
altclkctrl altpll_reconfig
altclklock altremote_update
altddio_bidir alstratixii_oct
altddio_in altufm_osc
altddio_out
altdq

Memory Compiler
altcsmem
(FIFO partitioner)

Flash Loader Megafunctions

parallel_flash_loader
altserial_flash_loader

SignalTap II Logic Analyzer

Megafunction
sld_signaltap

Storage Components
alt3pram scfifo
altcam lpm_ff
altdpram* lpm_fifo*
altqpram lpm_fifo_dc*
altshift_taps lpm_latch
altsyncram lpm_ram_dp
altufm_i2c lpm_ram_dq
altufm_none lpm_ram_io
altufm_parallel lpm_rom
altufm_spi lpm_shiftreg
csdpram* lpm_dff*
csfifo* lpm_tff*
dcfifo

Virtual JTAG Megafunction

sld_virtual_jtag
El siguiente ejemplo nos muestra un contador de 25 bits que se implementó
utilizando la LPM. Para su visualización podemos conectar todas las salidas del
contador a los Leds del quit de evaluación (tambien se puede conectar solo los
bits de mayor peso para observar como parpadean).

library ieee;
use ieee.std_logic_1164.all;
LIBRARY lpm;
USE lpm.lpm_components.all;

ENTITY led IS
PORT(
clk : IN STD_LOGIC;
sal : OUT STD_LOGIC_VECTOR(25 DOWNTO 0);
--podemos declarar sal como una salida de solo un
--bit para visualizar el bit de mayor peso
act : OUT STD_LOGIC);
END led;

ARCHITECTURE led_arch OF led IS

COMPONENT lpm_counter
GENERIC (LPM_WIDTH: NATURAL; LPM_MODULUS : NATURAL := 0);
PORT (clock : IN STD_LOGIC ; q: OUT STD_LOGIC_VECTOR(25 DOWNTO
0));
END COMPONENT;
BEGIN
Contador_3: lpm_counter
GENERIC MAP (LPM_WIDTH => 25,LPM_MODULUS =>33500000)
PORT MAP (clock => clk, q => sal);
--podemos declarar q(24)=>sal para visualizar solo un bita
act<='1';
--esta salida se usara para poner a nivel alto el pin TD_RESET y utilizar
el reloj de
--27 Mhz de acuerdo al manual del quit
END led_arch;

El siguiente ejemplo nos muestra el mismo contador de 25 bits pero ahora se

conecta a un segundo contador de 4 bits. El bit de mayor peso del primer
contador funje como reloj del segundo contador para que podamos visualizar
las salidas con claridad en los leds.

library ieee;
use ieee.std_logic_1164.all;
LIBRARY lpm;
USE lpm.lpm_components.all;

ENTITY led IS
PORT(
clk : IN STD_LOGIC;
sal: OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
 act : OUT STD_LOGIC);
END led;
ARCHITECTURE led_arch OF led IS
COMPONENT lpm_counter
GENERIC
(LPM_WIDTH : NATURAL; -- MUST BE GREATER THAN 0
LPM_MODULUS : NATURAL := 0;
LPM_DIRECTION : STRING := "UNUSED";
LPM_AVALUE : STRING := "UNUSED";
LPM_SVALUE : STRING := "UNUSED";
LPM_PORT_UPDOWN : STRING := "PORT_CONNECTIVITY";
LPM_PVALUE : STRING := "UNUSED";
LPM_TYPE : STRING := L_COUNTER;
LPM_HINT : STRING := "UNUSED");

PORT (data : IN STD_LOGIC_VECTOR(LPM_WIDTH-1

DOWNTO 0):= (OTHERS => '0');
clock : IN STD_LOGIC ;
clk_en, cnt_en, updown, cin : IN STD_LOGIC := '1';
sload, sset, sclr, aload, aset, aclr : IN STD_LOGIC := '0';
cout : OUT STD_LOGIC := '0';
q : OUT STD_LOGIC_VECTOR(LPM_WIDTH-1
DOWNTO 0);
eq : OUT STD_LOGIC_VECTOR(15 DOWNTO 0));
END COMPONENT;
SIGNAL RELOJ: STD_LOGIC;
BEGIN
Contador_25: lpm_counter
GENERIC MAP (LPM_WIDTH => 25,LPM_MODULUS =>33500000)
PORT MAP (clock => clk, q(24)=>RELOJ);
Contador_24: lpm_counter
GENERIC MAP (LPM_WIDTH => 4,LPM_MODULUS =>10)
PORT MAP (clock => RELOJ, q => sal);
act<='1';
END led_arch;
 EJEMPLO 3
UTILIZACION DE LOS DISPLAYS DE 7 SEGMENTOS

CONTADOR DE DECADAS

Planteamiento del problema:

Se desea implementar un contador de decadas (desde 0 hasta 9). Recibirá

como entrada una señal de reloj, una señal de habilitación (para detener o
continuar la cuenta) y una señal para reiniciar el contador. Como salidas
tendremos 7 pines para salida en displays de 7 segmentos.

Propuesta de solución:

Se utilizará el contador diseñado en ejemplos anteriores, el cual tiene un

modulo de 10 y cuenta con dos contadores concatenados, lo único que se hará
será agregar un decodificador para que sea posible desplegar en el display. Si
consideramos los segmentos de la siguiente manera (acorde al quit, para
visualizar los numeros de acuerdo a la conexión de los segmentos en el
FPGA):

library ieee;
use ieee.std_logic_1164.all;
LIBRARY lpm;
USE lpm.lpm_components.all;

ENTITY led IS
PORT(
clk : IN STD_LOGIC;
sal : OUT STD_LOGIC_VECTOR(6 DOWNTO 0);
act : OUT STD_LOGIC);
END led;
ARCHITECTURE led_arch OF led IS
COMPONENT lpm_counter
GENERIC
(LPM_WIDTH : NATURAL; -- MUST BE GREATER THAN 0
LPM_MODULUS : NATURAL := 0;
LPM_DIRECTION : STRING := "UNUSED";
LPM_AVALUE : STRING := "UNUSED";
LPM_SVALUE : STRING := "UNUSED";
LPM_PORT_UPDOWN : STRING := "PORT_CONNECTIVITY";
 LPM_PVALUE : STRING := "UNUSED";
LPM_TYPE : STRING := L_COUNTER;
LPM_HINT : STRING := "UNUSED");

PORT (data : IN STD_LOGIC_VECTOR(LPM_WIDTH-1

DOWNTO 0):= (OTHERS => '0');
clock : IN STD_LOGIC ;
clk_en, cnt_en, updown, cin : IN STD_LOGIC := '1';
sload, sset, sclr, aload, aset, aclr : IN STD_LOGIC := '0';
cout : OUT STD_LOGIC := '0';
q : OUT STD_LOGIC_VECTOR(LPM_WIDTH-1
DOWNTO 0);
eq : OUT STD_LOGIC_VECTOR(15 DOWNTO 0));
END COMPONENT;
SIGNAL RELOJ: STD_LOGIC;
SIGNAL se_al: STD_LOGIC_VECTOR(3 DOWNTO 0);
BEGIN
Contador_25: lpm_counter
GENERIC MAP (LPM_WIDTH => 25,LPM_MODULUS =>33500000)
PORT MAP (clock => clk, q(24)=>RELOJ);
Contador_4: lpm_counter
GENERIC MAP (LPM_WIDTH => 4,LPM_MODULUS =>10)
PORT MAP (clock => RELOJ, q => se_al);
PROCESS(se_al)
begin
case se_al is
when "0000" => sal <= "1000000";
when "0001" => sal <= "1111001";
when "0010" => sal <= "0100100";
when "0011" => sal <= "0110000";
when "0100" => sal <= "0011001";
when "0101" => sal <= "0010010";
when "0110" => sal <= "0000011";
when "0111" => sal <= "1111000";
when "1000" => sal <= "0000000";
when "1001" => sal <= "0011000";
when others => sal <= "1111111";
act<='1';
end case;
end process;
END led_arch;

Para la correcta visualización tenemos la siguiente asignación de pines a

manera de ejemplo:
UTILIZACIÓN DE UNA LCD

Las pantallas de cristal líquido o display LCD para mensajes (Liquid Cristal
Display) tienen la capacidad de mostrar cualquier carácter alfanumérico,
permitiendo representar la información que genera cualquier equipo electrónico
de una forma fácil y económica. La pantalla consta de una matriz de caracteres
(normalmente de 5 x 7 puntos) distribuidos en una, dos, tres o cuatro líneas de
16 hasta 40 caracteres cada línea. El proceso de visualización es gobernado
por un microcontrolador incorporado a la pantalla, siendo el Hitachi 44780 el
modelo más utilizado.

Figura No. Aspecto de un módulo TM162AD

DDRAM

Posee una zona de memoria RAM llamada DDRAM (Data Display RAM) donde
se almacenan los caracteres que se pueden representar. Tiene una capacidad
de 80 Bytes, 40 por cada línea, de los cuales solo 32 se pueden visualizar a la
vez (16 bytes por línea). La DDRAM almacena los códigos ASCII de los
caracteres que aparecerán en pantalla y existe una correspondencia entre las
filas de la pantalla y las posiciones consecutivas de memoria.
 DDRAM
De las 80 posibles, las dos direcciones mas importantes de la DDRAM son:

 Dirección 00h, que es el comienzo de la primera línea.

 Dirección 40h, que es el comienzo de la segunda línea.

Cada vez que se escribe un dato en la DDRAM automáticamente se apunta a

la siguiente posición, donde se realizará la escritura del próximo carácter.
 Caracteres definidos dentro de la tabla CGROM

MODOS DE FUNCIONAMIENTO

Una LCD tiene básicamente tres modos de funcionamiento principales:

 Modo Comando. Cuando por el bus de datos el LCD recibe instrucciones

como “borrar display”, “mover cursor”, “desplazar a izquierda”, etc. Para
trabajar en modo comando, el pin RS debe estar a “0”. El pin R/W
también debe ser “0” para indicar que se esta realizando una operación
de escritura. Una operación en este modo tarda un máximo de 1.64 ms.
  Modo Carácter o Dato. Cuando por el bus de datos el visualizador LCD
recibe un carácter a escribir en la DDRAM. Es decir, cuando se envía al
LCD el carácter ASCII a visualizar. Para trabajar en este modo, el pin
RS debe estar a “1”. El pin R/W debe ser “0” para indicar que esta
realizando una operación de escritura. También se le puede llamar
“modo carácter” o “modo registro”. Una operación en este modo tarda un
máximo de 40 μs.
 Modo lectura del “Busy Flag” o LCD Ocupada. En el bit 7 del bus de dato
el LCd informa al microcontrolador de que esta ocupado, (este bit es
denominado Busy Flag). Para ello se lee el bus de dato con RS=0 y
R/W=1, si el bit 7 del bus de datos es “1” indica que la pantalla LCD está
ocupada realizando operaciones internas y no puede aceptar nuevas
instrucciones ni datos. Hay que esperar a que el Busy Flag valga “0”
para enviarle la siguiente instrucción o carácter.

El modo de operación de lectura del Busy Flag se ha ideado para evitar

posibles problemas de tiempo, de manera que no se realiza ninguna operación
con el LCD hasta comprobar que no está ocupado. El pin R/W permite leer el
registro de estado en el modo Busy Flag que solo sirve para comprobar si el
controlador ha terminado de realizar la instrucción que se le ha enviado y así
poder enviar más.
Para un control sencillo, se pueden realizar pausas después de cada
instrucción o envió de datos para no tener que leer el registro de estado, con
ello se evita el modo de lectura del Busy Flag. La principal ventaja de esto es
que logra ahorrar un pin del microcontrolador porque la línea R/W no es
necesaria y se puede conectar directamente a tierra. La detección del busy
Flag se sustituye entonces por un pequeño retardo antes de realizar cualquier
nueva operación con el display LCD. Este retardo debe ser mayor de 1.64 ms
si se trabaja en modo comando y mayor de 40 μs si se trabaja en modo dato.

COMANDOS DE CONTROL

Los comandos que admite el modulo TM162AD se resume en la tabla.

COMANDO RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
Clear Display 0 0 0 0 0 0 0 0 0 1
Return Home 0 0 0 0 0 0 0 0 1 *
Entry Mode Set 0 0 0 0 0 0 0 1 I/D S
Display Control 0 0 0 0 0 0 1 D C B
Cursor and display
Shift 0 0 0 0 0 1 S/C R/L * *
Function Set 0 0 0 0 1 DL N F * *
Set CGRAM Address 0 0 0 1 CGRAM Address
Set DDRAM Address 0 0 1 DDRAM Address
Read Busy Flag 0 1 BF DDRAM Address
Write RAM 1 0 Write Data
Read RAM 1 1 Read Data

Comandos del visualizador LCD TM162AD

Los comandos se envían a través del bus de datos. Para que el LCD los
reconozca hay que poner la señal RS a nivel bajo. A continuación se detallan
los comandos y símbolos de esta tabla:

 Clear Display (0 0 0 0 0 0 0 1). Borra pantalla y devuelve el cursor a la

posición inicial (dirección 0 de la DDRAM)
 Return Home (0 0 0 0 0 0 1 X). Cursor a dirección de origen. Devuelve el
cursor la posición original de la DDRAM (dirección 00h) quedando
intacto su contenido.
 Entry Mode Set (0 0 0 0 0 1 I/D S). Modo entrada. Establece las
características de escritura de los datos Shift e Increment/Decrement:
o S = 0. La información visualiza en pantalla no se desplaza al
escribir un nuevo carácter.
o S = 1. La información visualizada se desplaza al escribir un nuevo
carácter. La pantalla se desplaza en el sentido indicado por
el bit I/D cuando el cursor llega al filo de la pantalla.
o I/D = 1. Incremento automático de la posición del cursor. La
posición de la DDRAM se incrementa automáticamente
tras cada lectura o escritura a la misma.
o I/D = 0. Decremento de la posición del cursor. Se decrementa el
puntero de la DDRAM.
 Display Control (0 0 0 0 1 D C B). Control de la pantalla:
o B = 0. Blink OFF, no hay efecto de parpadeo del cursor.
o B = 1. Blink ON, efecto de parpadeo con un cursor
rectangular.
o C = 0. Cursor OFF, el cursor no se visualiza.
o C = 1. Cursor ON, el cursor es visualizado.
o D = 0. Display OFF, el display se apaga.
o D = 1. Display ON, el display se enciende.

 Cursor and display Shift (0 0 0 1 S/C R/L x x). Control de los

desplazamientos del cursor y de la pantalla:

o R/L = 0. Left. A la izquierda.

o R/L = 1. Right. A la derecha.
o S/C = 0. El efecto del desplazamiento se aplica sólo sobre el
cursor sin alterar el contenido de la DDRAM.
o S/C = 1. El efecto de desplazamiento se aplica sobre todo el
display.
 Function Set (0 0 1 DL N F x x). Características de control hardware:
o F = 0. Font. Caracteres de 5 x 7 puntos.
o F = 1. Font. Caracteres de 5 x 10 puntos.
o N = 0. Number Line. Pantalla de 1 línea.
o N = 1. Number Line. Pantalla de 2 líneas.
o DL = 0. Data Length. Comunicación con 4 bits. Indica al
display LCD que solamente se van a utilizar las
líneas DB7, DB6, DB5 y DB4 para enviarle los datos
 y que se hará enviando primero el nibble alto, y a
continuación el nibble bajo del dato.
o DL = 1. Data length. Comunicación con 8 bits.
 Set CGRAM Address. Se va a escribir sobre la dirección CGRAM
señalada.
 Set DDRAM Addrees. (1 d d d d d d d). Esta instrucción se utiliza para
modificar el puntero a la DDRAM. Así por ejemplo, si la dirección es la
08h se escribirá en el centro de la primera línea.
 Read Busy Flag. Lee el BF indicando si hay una operación interna en
curso y lee, además, el contenido de la dirección DDRAM apuntada.

EJEMPLO 4
UTILIZACION DE LA PANTALLA DE CRISTAL LIQUIDO

DESPLIEGUE DE UN MENSAJE

Planteamiento del problema:

Se desea desplegar un mensaje en la pantalla que comenzará en la primera

posición de la primera linea de la pantalla. Se propone el mensaje “HOLA” a
manera de prueba.

Propuesta de solución:

Dado que es necesaria la habilitación de la pantalla y solo cuatro caracteres

seran desplegados, se ha optado por implementar como primer instancia una
máquina de estados que constará de 30 estados, los cuales serán gobernados
por un contador que avanzará a una velocidad de 2 ms.

El diagrama a bloques de este proceso se muestra a continuación, aclarando

que haremos uso de la LPM para implementar los comparadores y los
contadores.

Valor fijo Contador Entrada de reloj

del contador
b'11111' 5 bits
Máquina de
Señal: Cuenta estados
Numero b Numero a
5 bits 5 bits
Inicializa la
Señal: Salida lcd y
500 hz
Señal: Menor Se desconecta
Despliega e
Comparador =1 si a<b gracias al mensaje
comparador
Compara dos numeros de 5 bits
Da como salida un 1 logico si a<b =0 si a>=b
HOLA

clock
Reloj a 27 Mhz Contador
Señal: Reloj
0 a 5399 Reloj a 500 hz
16 bits

El programa quedaría como sigue

library ieee;
use ieee.std_logic_1164.all;
LIBRARY lpm;
USE lpm.lpm_components.all;

ENTITY Conta_7 IS
PORT(
clk : IN STD_LOGIC; --Entrada de relog a 50
Mhz
act : out std_logic; --para habilitar el relog de
27 Mhz
sal : inout std_logic_vector(7 downto 0); -- LCD data is a bidirectional bus...
Lcd_Sel : out std_logic; -- LCD register select
Lcd_Rw : out std_logic; -- LCD Read / nWrite
Lcd_En : out std_logic; -- LCD Enable
Lcd_on : out std_logic;
Lcd_blon : out std_logic);
END Conta_7;

ARCHITECTURE Trunca OF Conta_7 IS

COMPONENT lpm_counter
GENERIC
(LPM_WIDTH : NATURAL; -- MUST BE GREATER THAN 0
LPM_MODULUS : NATURAL := 0;
LPM_DIRECTION : STRING := "UNUSED";
LPM_AVALUE : STRING := "UNUSED";
LPM_SVALUE : STRING := "UNUSED";
LPM_PORT_UPDOWN : STRING := "PORT_CONNECTIVITY";
LPM_PVALUE : STRING := "UNUSED";
LPM_TYPE : STRING := L_COUNTER;
LPM_HINT : STRING := "UNUSED");

PORT (data : IN STD_LOGIC_VECTOR(LPM_WIDTH-1

DOWNTO 0):= (OTHERS => '0');
clock : IN STD_LOGIC ;
clk_en, cnt_en, updown, cin : IN STD_LOGIC := '1';
sload, sset, sclr, aload, aset, aclr : IN STD_LOGIC := '0';
cout : OUT STD_LOGIC := '0';
q : OUT STD_LOGIC_VECTOR(LPM_WIDTH-1
DOWNTO 0);
eq : OUT STD_LOGIC_VECTOR(15 DOWNTO 0));
END COMPONENT;

COMPONENT lpm_compare
GENERIC
(LPM_WIDTH : POSITIVE;
LPM_REPRESENTATION : STRING := "UNSIGNED";
LPM_PIPELINE : INTEGER := 0;
LPM_TYPE : STRING := "LPM_COMPARE";
LPM_HINT : STRING := "UNUSED");
PORT (dataa, datab : IN STD_LOGIC_VECTOR(LPM_WIDTH-1
DOWNTO 0);
aclr, clock : IN STD_LOGIC := '0';
clken : IN STD_LOGIC := '1';
agb, ageb, aeb, aneb, alb, aleb : OUT STD_LOGIC );

END COMPONENT;

-- Comando Function set, Comunicacion de 8 bits, pantalla de 2 lineas y

caracteres de 5X7
constant SET : std_logic_vector(7 downto 0) := "00111000"; --001 DL N F X X
-- Comando Display ON, Cursor parpadeando y visible
constant DON : std_logic_vector(7 downto 0) := "00001111";
-- Comando Entry Mode Set,incremento automatico de la posición, la
informacion se
-- visualiza y el cursor se deslaza automáticamente
constant EMS : std_logic_vector(7 downto 0) := "00000111";
-- Comando Clear screen
constant CLR : std_logic_vector(7 downto 0) := "00000001";

SIGNAL cuenta: std_logic_vector(4 downto 0);

SIGNAL menor: STD_LOGIC;
SIGNAL reloj: STD_LOGIC; --Reloj a 1 segundo
SIGNAL salida: STD_LOGIC;

BEGIN

Comparador_4: lpm_compare
GENERIC MAP (LPM_WIDTH => 5)
PORT MAP (dataa=>cuenta,datab=>"11111",alb=>menor);
Contador_16: lpm_counter
GENERIC MAP (LPM_WIDTH => 16,LPM_MODULUS => 53999)
PORT MAP (clock => clk, q(15)=>reloj);
Contador_4: lpm_counter
GENERIC MAP (LPM_WIDTH => 5,LPM_MODULUS =>30)
PORT MAP (clock => salida, q => cuenta);
salida <= menor and reloj;
Lcd_Rw <= '0'; -- LCD en estado permanente de escritura
act<='1';
Lcd_on<='1';
Lcd_blon<='1';
PROCESS(cuenta)
begin

case cuenta is

when "00000" =>

--estado de inicialización espera 15 milisegundos
--o hasta que la cuenta llegue a 8
Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00001" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00010" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00011" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00100" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00101" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00110" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "00111" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "01000" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --para 1 : Modo Caracter, para 0 : Modo Comando
sal <= (others=>'0'); --Todas las salidas se pasan a cero

when "01001" =>

--cuando la cuenta llegó a 9 procedemos con el function set
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces (1)
when "01010" =>
Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces

when "01011" =>

Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces (2)

when "01100" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces

when "01101" =>

Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces (3)

when "01110" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= SET; --El function set debe mandarse junto con un pulso de enable
3 veces

when "01111" =>

--Se procede con la configuracion del display
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= DON; --Configuracion para el display

when "10000" =>

--Se procede con la configuracion del display
Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= DON; --Configuracion para el display

when "10001" =>

--se prcede con la configuracion del modo entrada
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= EMS; --Configuracion para el modo entrada

when "10010" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= EMS; --Configuracion para el modo entrada

when "10011" =>

--Se limpia la pantalla
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= CLR;

when "10100" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo Comando
sal <= CLR;

when "10101" =>

--se establece la direccion de la RAM
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo caracter
sal <= "10000100"; -- Escritura en la Direccion 16 primer linea

when "10110" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '0'; --Modo caracter
sal <= "10000100"; --Escritura en la Direccion 16 primer linea

when "10111" =>

--Se procede al modo escritura
Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001000"; --codigo de la letra H

when "11000" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001000"; --codigo de la letra H

when "11001" =>

Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001111"; --codigo de la letra O

when "11010" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001111"; --codigo de la letra O

when "11011" =>

Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001100"; --codigo de la letra L

when "11100" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01001100"; --codigo de la letra L

when "11101" =>

Lcd_En <= '1'; --Se habilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01000001"; --codigo de la letra A

when "11110" =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo caracter
sal <= "01000001"; --codigo de la letra A

when others =>

Lcd_En <= '0'; --Se deshabilita temporalmente la LCD
Lcd_Sel <= '1'; --Modo escritura
sal <= "00000000"; --codigo de la letra
end case;

end process;
END Trunca;

UTILIZACIÓN DEL TFT LCD (PANTALLA GRÁFICA)

Las practicas que se realizan se enfocan a ejemplificar el uso de un modulo

TFT LCD (Thin Film Transistor-Liquid Crystal Display) es una variante de
pantalla de cristal líquido (LCD) que usa tecnología (TFT) de transistor de
película fina para mejorar la respuesta y la calidad de la imagen y los colores
mostrados, así como la velocidad de respuesta. Son usados en televisores,
visualizadores de pantalla plana y proyectores. En la computación, los
monitores de TFT están desplazando la tecnología de TRC compitiendo
rápidamente, y están comúnmente disponible en los tamaños de 12 a 30
pulgadas. Desde 2006, han hecho las incursiones sobre el mercado de la
televisión también.

El modelo especifico sobre el que se realizará el trabajo es el TD036THEA1,

por ser el que contiene el quit DE2 que se esta programando.