Este documento presenta el código HDL para un decodificador BCD a 7 segmentos. Describe la interfaz del decodificador, incluyendo las entradas, salidas y funciones. Explica conceptos clave como palabras reservadas, vectores, funciones y case statements. Finalmente, los estudiantes proporcionan conclusiones sobre las similitudes entre la programación HDL y los lenguajes de alto nivel como Java.

1. 1
INSTITUTO TECNOLÓGICO SUPERIOR DE
FELIPE CARRILLO PUERTO
Ingeniería En Sistemas Computacionales
Principios Eléctricos y sus Aplicaciones
Digitales (PEAD)
Unidad 4: Lenguajes HDL
Informe Técnico unidad 4
Profesor:
Niels Henryk Aranda Cuevas
Integrantes:
Angel Felipe Suaste Tuz
Carla Balam Méndez
Luis Antonio Chan Chuc
Miriam Candelaria Poot Pech
Bella Areli Pérez Gómez.
Irving Saúl Che Canul

2. 2
AULA: J-4 GRUPO: B
27/06/14
Contenido
INTERFAZ DEL DECODIFICADOR.......................................................................................................... 3
CODIGO ORIGINAL SIN COMENTARIOS............................................................................................... 7
CONCLUSIONES ................................................................................................................................. 10
Conclusión Angel Felipe Suaste Tuz .............................................................................................. 10
Conclusión Carla Balam Méndez................................................................................................... 11
Conclusión Luis Antonio Chan Chuc.............................................................................................. 11
Conclusión Miriam Candelaria Poot Pech..................................................................................... 11
Conclusión Bella Areli Pérez Gómez.............................................................................................. 11
Conclusión Irving Saúl Che Canul .................................................................................................. 11

3. 3
INTERFAZ DEL DECODIFICADOR
------------------------------------------------------------------
//CODIGO GENERADO POR EL EDITOR XILINX
//IMPORTANTE: EN EL LENGUAJE HDL PARA HACER COMENTARIOS SE HACE
CON USANDO DOBLE GUION (--).
-- Company:
-- Engineer:
-- Create Date: 16:37:25 12/05/2013
-- Design Name:
-- Module Name: Interfaz - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
-- Dependencies:
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
------------------------------------------------------------------
LIBRARY ieee; //Es una librería del lenguaje, parecidos al del
lenguaje C
USE ieee.std_logic_1164.ALL; //especifica la librería de ieee a
utilizar en este caso se está utilizando el std_logic_1164 el .ALL
significa que usará todo de esa librería.
entity Interfaz is //aquí se declara la entidad Interzaz, una
entidad tiene extradas y salidas.
//entity, is, port son palabras reservadas del lenguaje
//las palabras in y out denota entrada y salida respectivamente
Port ( BCD : in STD_LOGIC_VECTOR (3 downto 0); //aquí se
declara un vector que va de 3 a 0, con esto se listan 4 elementos
3,2,1,0.
//esto es así porque es un decodificador BCD a 7 segmentos de 4
bits, por eso se necesita un vector de 4 elementos (3, 2, 1, 0) la
cual nombramos por BCD.
SieteSeg : out STD_LOGIC_VECTOR (6 downto 0); //aquí
se declara otro arreglo llamado SieteSeg es de salidad que va de 6
a 0 (6,5,4,3,2,1,0) son los 7 segmentos del display.

4. 4
Selector : out STD_LOGIC_VECTOR (3 downto 0));//aquí
se declara otro arreglo llamado Selector es de salida (out) y es
de 4 elementos por eso va de 3 a 0.
end Interfaz; //aquí se termina de declarar las características de
la entidad Interfaz
architecture Behavioral of Interfaz is //aquí es donde inicia la
codificación, para darle funcionamiento a la entidad, se puede
decir que es la parte lógica.
//architecture, Behavioral e is son palabras reservadas del
lenguaje como lo es Java con palabra class o public.
function Deco(bcd: std_logic_vector(3 downto 0))
return std_logic_vector is
variable Salida: std_logic_vector(6 downto 0);
/*las tres líneas anteriores tenemos la declaración de una
función y lo que va a regresar,la primera línea es la declaración
de la función en este caso se llama Deco, como se puede ver tiene
un parámetro, la cual es un vector de tamaño 4.
//esta declaración debe estar bastante clara, es como programar en
java cuando se declaran métodos con parámetros, que son valores
que se le pasan al método.*/
/*La segunda y la tercera línea es lo que regresa, o sea es una
salidad y vemos que regresa un vector del tipo std_logic_ vector
solo que ahora es de tamaño 7, la cual se declara mediante
variable seguido del nombre Salida, esto es porque estamos
convirtiendo binarios a decimar y lo cual se hace en un display de
7 segmentos, una vez más muy parecido a Java*/
//aquí function, return, std_logic_vector y variable son palabras
reservadas.
Begin //aquí se inicia la codificación, la palabra
begin es una palabra reservada
case bcd is //el uso de case, es muy parecido al que
tiene en Java cuando usamos Switch.

5. 5
//el código que sigue, ya debe de ser conocido cuando los 4 bits
están en cero la salida debe ser 0, pero recordemos que lo estamos
haciendo en un 7 segmentos.
ACLARACION: usamos 1 para apagado y 0 para encedido.
when "0000" => Salida:="0000001";
when "0001" => Salida:="1001111";
when "0010" => Salida:="0010010";
when "0011" => Salida:="0000110";
when "0100" => Salida:="1001100";
when "0101" => Salida:="0100100";
when "0110" => Salida:="0100000";
when "0111" => Salida:="0001111";
when "1000" => Salida:="0000000";
when "1001" => Salida:="0000100";
when others => Salida:="1111111";
end case; //fin del case
//when, end y case son palabras reservadas
return Salida; //regresa el vector Salida
end Deco; //fin de la función Deco.
begin
SieteSeg<=Deco(BCD);
//la línea anterior es muy importante, sin esa declaración no va a
funcionar el decodificador.
//EXPLICACION: Recordemos que una entidad en HDL tiene entradas y
salidas.
En este ejemplo tenemos una entrada la cual la llamos BCD y la
salida la llamamos SieteSeg.
Ya codificamos lo que va a hacer con las entradas pero no hemos
puesto el código de salida.
// La declaración SieteSeg<=Deco(BCD) es donde se hace la salida
veamos que asignamos a SieteSeg la función Deco la cual recibe
como parámetro un arreglo llamado BCD, que es el nombre de la
entrada para la entidad Interfaz.
end Behavioral;

6. 6
CODIGO ORIGINAL SIN COMENTARIOS
------------------------------------------------------------------
-- Company:
-- Engineer:
-- Create Date: 16:37:25 12/05/2013
-- Design Name:
-- Module Name: Interfaz - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
-- Dependencies:
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;
-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity Interfaz is
Port ( BCD : in STD_LOGIC_VECTOR (3 downto 0);
SieteSeg : out STD_LOGIC_VECTOR (6 downto 0);
Selector : out STD_LOGIC_VECTOR (3 downto 0));
end Interfaz;
architecture Behavioral of Interfaz is
function Deco(bcd: std_logic_vector(3 downto 0))
return std_logic_vector is

7. 7
variable Salida: std_logic_vector(6 downto 0);
begin
case bcd is
when "0000" => Salida:="0000001";
when "0001" => Salida:="1001111";
when "0010" => Salida:="0010010";
when "0011" => Salida:="0000110";
when "0100" => Salida:="1001100";
when "010uu1" => Salida:="0100100";
when "0110" => Salida:="0100000";
when "0111" => Salida:="0001111";
when "1000" => Salida:="0000000";
when "1001" => Salida:="0000100";
when others => Salida:="1111111";
end case;
return Salida;
end Deco;
begin
SieteSeg<=Deco(BCD);
end Behavioral;

8. 8
CONCLUSIONES
Conclusión Angel Felipe Suaste Tuz
A modo de conclusión puedo decir que la programación HDL es tan interesante como programar
en alto nivel, claro que no se pueden igualar ya que en lenguajes de alto se programa software y
en este lenguaje se programa a nivel hardware lo nos da más posibilidades de hacer grandes
cambios en las estructuras, es decir, si en la programación de alto nivel se pueden hacer maravillas
en este lenguaje se puede hacer magia.
Similitudes del HDL con lenguajes de alto nivel:
 Ambos tienen palabras reservadas.
 Ambos utilizan funciones.
 Las funciones tanto en HDL y Java (lenguaje de alto nivel) aceptan parámetros.
 Tienen un inicio y un fin (begin y end, {} el uso de llaves en Java o C++).
 Usan arreglos.
 Usan librerías y paqueterías.
 El uso de entidades en el HDL es parecido al uso de clases en Java.
 El uso de entradas y salidas.
Como podemos observar tienen muchos parecidos, no significa que sean iguales, el punto es que
sabiendo lenguaje de alto nivel puede facilitar la programación en este tipo de lenguajes de bajo
nivel.
En nuestra aplicación de muestra usamos palabras reservadas como:
 entity: Sirve para declarar una entidad como es como declarar una clase en java usando
class.
 is
 port va antes de usar las palabras in o out.
 las palabras in y out denota entrada y salida respectivamente
 library sirve para llamar librerías, es como usar import en java.
 architecture y Behavioral después de la palabra architecture se codifica todo lo que se
desee que haga la entidad, dentro de architecture se usan las funciones.
 function y return, function sirve para declarar una funcion y return sirve para declarar lo
que devuelve esa función, muy parecido como se hace en java.
 std_logic_vector, sirve para declar vectores.
 variable, sirve para declarar variables.
 begin, nos indica el inicio de un bloque de códigos, tal como el uso de las llaves en C o C++.
 end, indica el fin de un bloque de códigos como lo hace la llave }.

9. 9
 case y when tienen una funcion parecido al uso de switch y case en java, este caso
después de case se pone la variable a evaluar y when que significa cuando sirve para que
código se ejecuta cuando se tiene diferentes valores de la variable a evaluar.
Conclusión Carla Balam Méndez
La programación en HDL estuvo muy interesante. Claro como tenemos las bases de java hubo
momentos en las que entendías bien los códigos porque había códigos similares a los que maneja
java. Como por ejemplo ambos manejan palabras reservadas, utilizan funciones, se tiene
parámetros, en java utilizamos llaves y en el lenguaje hdl utilizamos palabras reservadas para el
inicio y fin, begin y end respectivamente, se usan arreglos, utiliza librerías y paqueterías, uso de
entrada y salida.
En nuestra aplicación se pueden ver las similitudes mencionadas anteriormente. Cabe mencionar
que es un lenguaje de bajo nivel.
Es por tanto que si se llega a profundizar en este lenguaje habría muchísimas formas de sacarle
provecho.
Conclusión Luis Antonio Chan Chuc
El lenguaje HDL se utiliza para programación de circuitos. Es muy interesante ya que se concentra
en hardware, al igual como los otros lenguajes este trae palabras reservadas, funciones, librerías,
entre otras similitudes, la diferencia es que se codifica de otra forma y/o estructura.
En la aplicación que nosotros analizamos, se usan las palabras reservadas como entity (que
declarar una entidad), is, port, architectura (dentro de este se usan las funciones que se
requieran), when (se usa para cumplir una condición o serie de condiciones “case”; para
terminarlo se utiliza end case), Variable sirve para declarar variable, fuction sirve para declarar
función y return muestra lo que devuelve la funcion. También se utiliza library para llamar a las
librerías requeridas, también esta begin que funciona como una llave o serie de códigos.
Conclusión Miriam Candelaria Poot Pech
En conclusión con esta aplicación con la cual nos orientamos más a la programación de bajo nivel,
conociendo acerca de la programación HDL nos pudimos dar cuenta de que programar en bajo
nivel es muy similar a la programación de alto nivel, entonces se puede decir que si ya sabemos
programar en alto nivel no será tan complicado hacerlo a bajo nivel.
En cuando al código que se muestra anteriormente en el que podemos darnos cuenta de cómo se
programa a bajo nivel lo que ya habíamos hecho físicamente en un protoboard, en este caso es
bastante corto y sencillo ya que como pudimos ver en los comentarios nos mencionaba que todo
lo que usamos para programar en alto nivel es exactamente igual excepto que estos tiene otro
nombre, estas son algunas de las que se usan:
Entity, is, port, las palabras in y out denota entrada y salida respectivamente, library tiene la
misma función import en java. Architecture, Behavioral, function y return, function,

10. 10
std_logic_vector, sirve para declar vectores, variable que sirve para declarar variables, begin, end,
case y when.
Conclusión Bella Areli Pérez Gómez.
Se aplicaron librerías como "entity Interfaz is" que declara la entidad interfaz la cual contiene una
entrada y salida las cuales las podemos denotar respectivamente con in y out.
Para la declaración de un vector tomamos en cuenta a "port" programamos la parte lógica de
nuestro decodificado mandando flujo a la entradas y salidas; al igual que la "architecture
Behavioral of Interfaz is " le da inicio al codificador, podríamos indicar que es la parte lógica. En el
programa el codificador se muestra de forma contraria.
En la programación HDL se denotas las diversas estructuras de la programación a pesar de ser bajo
nivel.
Conclusión Irving Saúl Che Canul
El lenguaje HDL es una interfaz enfocada a la programación a nivel hardware, como hemos visto
en java la implementación de comentarios se definen con una doble diagonal, en el caso de este
lenguaje son definidas con un guion medio, la utilización de paqueterías y clases es muy diferente
así como la declaración de una variable.
El paquete library ieee; hace referencia a la paquetería que se utilizara durante la programación
USE ieee.std_logic_1164.ALL le indica a la paquetería ieee que se utilizara todo el contenido de
esa librería.
Entity es una interfaz declarada la cual tiene dos tipos de entidades las cuales son de entrada y de
salida.
Las formas de cómo se define un vector el cual servirá para el control, los cuales controlan 4
elementos diferentes, se declaran un arreglo el cual es selector para las salidas, al igual que se
define un inicio se declara el final de la interfaz que controlara una parte especifica del hardware.
Architecture behavioral of interfaz is . es una de las partes más importantes en el cuerpo de esta
programación, pues aquí se define el funcionamiento lógico de la entidad.