Sistemas Embebidos

INSTITUTO TECNOLGICO DE TEHUACAN

Ingeniera ELECTRONICA
Materia: Sistemas Embebidos
Reporte de prctica:
contadores multiplexados
Catedrtico: Dr. Oscar L. Prez C.
INTEGRANTES DEL EQUIPO:
Velasco Calleja Liliana
Garca Mrquez Omar Ulisses
Nmeros DE CONTROL:
10360535
10360518


Sistemas Embebidos


Objetivo de la prctica: aplicar la tcnica de multiplexado en lenguaje VHDL para poder visualizar
cuatro contadores diferentes a travs de los 4 displays de siete segmentos que trae integrada la
tarjeta Basys 2.
Descripcin de la prctica: disear e implementar a travs de la tarjeta Basys 2 un circuito que
visualice cuatro contadores diferentes de un solo digito, cada uno en uno de los displays integrados
de la tarjeta Basys 2, el cual deber tener una entrada externa llamada SELECCIONAR_MODO
para que dependiendo de su valor, realice lo siguiente:
SELECCIONAR_MODO Descripcin
0
Visualiza automticamente los cuatro contadores al mismo
tiempo en cada uno de los display correspondientes.
1
Visualiza un contador a la vez en un solo display, el cual
dependiendo de las dos entradas externas se visualizara el
tipo del contador en el display correspondiente (forma
manual).
De acuerdo a las entradas que tenga en modo manual, realizar lo que se describe a continuacin:
IN_EXTERNA(1) IN_EXTERNA(0) Descripcin
0 0
Contador ascendente de 0-9 que se visualizar
en el display menos significativo (AN0).
0 1
Contador descendente de 9-0 que se visualizara
en el segundo display (AN1).
1 0
Contador ascendente de nmeros pares de 0-8
que se visualizar en el tercer display (AN2).
1 1
Contador descendente de nmeros pares de 8-
0 que se visualizar en el display ms
significativo (AN3).

Los contadores deben ser de baja frecuencia (1 Hz) de tal modo que podamos observar claramente
el cambio entre un nmero y otro. Tambin supondremos que ya se tiene el conocimiento de cada
una de las partes que conforman el software ISE Design Suite 13.4 y se est familiarizado con su
uso.
Desarrollo de la prctica
Para poder llevar a cabo satisfactoriamente el objetivo planteado en la descripcin de la prctica, es
necesario hacer primero un anlisis minucioso de que es lo que necesitamos para poder lograr el

Sistemas Embebidos


objetivo. Para ello tenemos que plantear que es lo que requerimos dentro de nuestro diseo
estructural, definir las entradas y salidas de nuestro modulo principal, entre otros puntos importantes.
Para lograr el objetivo, utilizaremos el modo de diseo estructural en VHDL, es decir, dividiremos
todo nuestro problema en bloques (o mdulos) ms elementales o bsicos, para que asi al final,
hagamos la interconexin entre estos bloques y obtengamos los deseado. Comenzando con el
anlisis del objetivo planteado, podemos crear una lista de bloques que necesitamos, como a
continuacin se muestra.
Un bloque divisor de frecuencia
Un bloque de contadores (ascendente, descendente, ascendente par, descendente par).
Un bloque decodificador de binario a 7 segmentos para los displays.
Un bloque de seleccin del display en el que queremos visualizar el contador.
Un bloque contador de 2 bits para generar automticamente las entradas externas.
Un bloque de seleccin del modo (automtico o manual) en el cual estar trabajando
nuestro sistema.
El primer bloque, el divisor de frecuencia, se encargar de disminuir la frecuencia del reloj que viene
integrado en la tarjeta en el puerto B8, que es de 50 MHz, a una frecuencia baja de 1 Hz para el
bloque de contadores. Este bloque tendr una entrada de reloj de alta frecuencia y tambin tendr
una salida de reloj, pero de baja frecuencia.
El segundo bloque que es el de contadores, contendr los 4 tipos de contadores que vamos a
visualizar, pero dependiendo del valor ledo desde las entradas externas, canalizaremos a la salida
de este bloque el contador deseado. Entonces, este bloque tendr una entrada de reloj de baja
frecuencia, para poder contar los pulsos que lleguen; una entrada de dos bits para poder canalizar a
la salida el contador deseado y una salida de 4 bits que es la resolucin del contador para poder
contar hasta 9.
El tercer bloque contendr un decodificador para poder visualizar los datos binarios de 4 bits que
lleguen desde el contador, en un display de nodo comn que son los que vienen integrados en la
tarjeta. Por lo tanto, este bloque contendr una entrada de 4 bits y una salida de 7 bits.
El cuarto bloque se trata de un multiplexor, el cual dependiendo del valor de la entrada externa,
activaremos el display correspondiente del contador a visualizar. Por lo tanto, este bloque tendr una
entrada de dos bits, y una salida de 4 bits.
El quinto bloque se trata de un contador de dos bits, pero de mayor frecuencia que los otros, para
poder automatizar cada una de las combinaciones de las entradas externas. Por lo tanto, tendr una
entrada de reloj y una salida dos bits.
El sexto y ltimo bloque se trata tambin de un multiplexor, el cual nos servir para determinar si la
entrada externa ser de forma manual o automtica. Por lo tanto, tendr una entrada de un bit para
la seleccin del modo, dos entradas de dos bits, y una salida tambin de dos bits.

Sistemas Embebidos



Figura 1.- Diagrama de bloques de la prctica.
En la figura 1 tenemos el diagrama a bloques de la prctica y podemos observar cmo estn
interconectados cada uno de los bloques (o mdulos) que estarn dentro del mdulo principal y que
implementaremos en la FPGA, que en el diagrama a bloques seria todos los bloques que se
encuentran dentro del recuadro rojo. Lo que se encuentra fuera de este recuadro son los recursos de
la tarjeta que emplearemos en el fichero (archivo) de asociacin de puertos.
Despus de haber analizado y planteado todo lo que requeriremos para cumplir con el objetivo,
procedemos a crear formalmente el proyecto. Para esto abrimos el software ISE Design Suite 13.4 y
creamos un nuevo proyecto, el cual le pondremos el nombre
contadores_multiplexados. Despus de crear el proyecto, agregamos un mdulo VHDL
para el divisor de frecuencia, el cual se presenta a manera de bloque a continuacin en la figura 2 y
le pondremos el nombre de divisor_de_frecuencia.

La entrada CLK es un tren de pulsos a una frecuencia de 50 MHz, y la salida CLK_1S es tambin
un tren de pulsos pero a una frecuencia de 1 Hz. La frecuencia de entrada tiene un periodo

y la frecuencia de salida tiene un periodo , es decir, el cambio entre cada contador

se dar a cada segundo transcurrido. Para poder disminuir la frecuencia de entrada, necesitamos

Sistemas Embebidos


contar los pulsos necesarios para generar un segundo, y as cada determinado valor de pulsos
contados, se invertir el estado de una salida, la cual ser la salida pero con baja frecuencia.
La frecuencia de salida tiene un periodo de 1 seg, y tendr un ciclo de trabajo del 50%, por lo que
permanecer en nivel alto durante 500 mSeg. Entonces, calculamos los pulsos necesarios para que
cada 500 mSeg se invierta el valor de la salida. Para esto, dividimos el tiempo en nivel alto entre el
periodo de la seal de entrada, es decir,


y este es el
nmero de pulsos a contar para que se invierta la salida consecutivamente transcurridos estos
pulsos.
Entonces, ya agregado nuestro modulo del divisor de frecuencia, el cdigo VHDL debe quedar de la
siguiente manera.
fichero divisor_de_frecuencia.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity divisor_de_frecuencia is
Port ( CLK : in STD_LOGIC;
CLK_1S : out STD_LOGIC);
end divisor_de_frecuencia;

architecture Behavioral of divisor_de_frecuencia is
signal conta_1s : std_logic_vector( 27 downto 0);
signal CLK_SALIDA : std_logic;
begin

process(CLK)
begin
if(CLK'event and CLK='1') then
conta_1s <= conta_1s + 1;
if (conta_1s = 25000000) then
CLK_SALIDA <= not CLK_SALIDA;
conta_1s <= (others =>'0');
end if;
end if;
end process;

CLK_1S <= CLK_SALIDA;
end Behavioral;

Verificamos la sintaxis dando doble clic en Check Syntax y verificamos que no haya errores.
Entonces ya hemos creado el primer mdulo.

Sistemas Embebidos


Despus de esto, creamos el siguiente modulo, que ser el bloque de contadores. Este bloque
contendr en su interior cuatro contadores diferentes, los cuales estarn asignados a seales dentro
de la arquitectura del mdulo. En la siguiente figura (figura 3) se muestra el bloque de los
contadores.

Con la entrada de dos bits SELEC_CONTA seleccionamos que contador se visualizara a la salida
del bloque OUT_CONTADOR. Agregamos un nuevo mdulo con el nombre counters al
proyecto y entonces, el cdigo nos queda de la siguiente manera.
fichero counters.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity counters is
Port ( CLK_in : in STD_LOGIC;
SELEC_CONTA : in STD_LOGIC_VECTOR (1 downto 0);
OUT_CONTADOR : out STD_LOGIC_VECTOR (3 downto 0));
end counters;

architecture Behavioral of counters is
signal Q_asc_consecutivo : std_logic_vector (3 downto 0);
signal Q_des_consecutivo : std_logic_vector (3 downto 0);
signal Q_asc_pares : std_logic_vector (3 downto 0) := "0000";
signal Q_des_pares : std_logic_vector (3 downto 0) := "0000";

begin
PROCESO_1 :
process (CLK_in)
begin
if (CLK_in'event and CLK_in='1') then
Q_asc_consecutivo <= Q_asc_consecutivo + 1;
if (Q_asc_consecutivo = "1001") then
Q_asc_consecutivo <= "0000";
end if;
end if;

Sistemas Embebidos


end process;

PROCESO_2 :
process (CLK_in)
begin
if (CLK_in'event and CLK_in='1') then
Q_des_consecutivo <= Q_des_consecutivo - 1;
if (Q_des_consecutivo = "0000") then
Q_des_consecutivo <= "1001";
end if;
end if;
end process;

PROCESO_3 :
process (CLK_in)
begin
if (CLK_in'event and CLK_in='1') then
Q_asc_pares <= Q_asc_pares + 2;
if (Q_asc_pares = "1000") then
Q_asc_pares <= "0000";
end if;
end if;
end process;

PROCESO_4 :
process (CLK_in)
begin
if (CLK_in'event and CLK_in='1') then
Q_des_pares <= Q_des_pares - 2;
if (Q_des_pares = "0000") then
Q_des_pares <= "1000";
end if;
end if;
end process;

with SELEC_CONTA select
OUT_CONTADOR <= Q_asc_consecutivo when "00",
Q_des_consecutivo when "01",
Q_asc_pares when "10",
Q_des_pares when "11",
Q_asc_consecutivo when others;
end Behavioral;

Como podemos ver, al final del programa es donde se lleva a cabo la asignacin de la salida
dependiendo de la seleccin del contador. Guardamos los cambios y verificamos la sintaxis. Si no
hay problemas en la compilacin, proseguimos con el siguiente mdulo.

Sistemas Embebidos


El siguiente modulo por agregar es decodificador para el display de 7 segmentos. Los displays que
trae integrado la tarjeta son displays de nodo comn, por lo que la implementacin se har para
este tipo de display. El bloque de este mdulo se muestra a continuacin en la figura 4.

Este mdulo tiene una entrada de 4 bits que vendr del bloque de contadores, y una salida de 7 bits
que ira directo a los segmentos de los displays. La declaracin del vector SALIDA ser (0 to
6), esto con el objetivo de facilitar la asignacin de puertos, por lo que al segmento a le
corresponder SALIDA(0), el segmento b le corresponder SALIDA(1) y as sucesivamente
hasta el segmento g que corresponder con SALIDA(6). Entonces agregamos un mdulo VHDL
a nuestro proyecto el cual tendr el nombre decodificador_7seg, y el cdigo debe de
quedar como se muestra a continuacin.

fichero decodificador_7seg.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity decodificador_7seg is
Port ( DATO_ENTRADA : in STD_LOGIC_VECTOR (3 downto 0);
SALIDA : out STD_LOGIC_VECTOR (0 to 6));
end decodificador_7seg;

architecture Behavioral of decodificador_7seg is

begin
with DATO_ENTRADA select
SALIDA <= "0000001" when "0000" , -- 0
"1001111" when "0001" , -- 1
"0010010" when "0010" , -- 2
"0000110" when "0011" , -- 3
"1001100" when "0100" , -- 4
"0100100" when "0101" , -- 5
"1100000" when "0110" , -- 6

Sistemas Embebidos


"0001111" when "0111" , -- 7
"0000000" when "1000" , -- 8
"0001100" when "1001" , -- 9
"1110010" when others; -- c
end Behavioral;

Una vez agregado el cdigo anterior a nuestro modulo, guardamos y verificamos la sintaxis. Si no
marca ningn error proseguimos con el siguiente bloque.
Despus de esto, agregamos un cuarto modulo a nuestro proyecto, el cual se encargara de generar
el contador de 2 bits para poder automatizar la visualizacin de los contadores en cada uno de los
displays correspondientes. El bloque de este mdulo se muestra a continuacin en la figura 5.

Para poder automatizar la entrada del bloque de contadores y la seleccin del display
correspondiente a cada contador, de manera que se logre el efecto visual de que todos los displays
estn trabajando al mismo tiempo, necesitamos estar seleccionando el contador y su respectivo
display a alta frecuencia, y as lograr el efecto deseado. Para ello, la salida de este bloque ser un
contador de 2 bits, el cual llevara la cuenta (00, 01, 10 y 11) a alta frecuencia. Este contador va a
contar los pulsos de entrada de este bloque, los cuales por supuesto tambin sern de alta
frecuencia. Por tanto, necesitamos incluir dentro de este bloque un divisor de frecuencia, el cual,
genere un tren de pulsos con una frecuencia igual a 2 KHz, que es una frecuencia lo suficientemente
alta para lograr el efecto.
La entrada de este bloque llamada CLK, ser la seal de reloj interna de la tarjeta, y la seal de
salida del bloque ser un contador de 2 bits (CONTADOR_2BITS). Se hacen los clculos para el
nmero de pulsos necesarios para obtener 2 KHz de frecuencia como se hizo anteriormente, y
tenemos que es necesario contar 25000 pulsos para lograr dicha frecuencia. Agregamos un nuevo
mdulo VHDL al proyecto, el cual le ponemos el nombre de conta_mux, y nuestro cdigo queda
de la siguiente manera.
fichero conta_mux.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;


Sistemas Embebidos


entity conta_mux is
Port(CLK : in STD_LOGIC;
CONTADOR_2BITS : out STD_LOGIC_VECTOR (1 downto 0));
end conta_mux;

architecture Behavioral of conta_mux is

signal conta_10ms : std_logic_vector( 27 downto 0);
signal CLK_2K : std_logic;
signal Q : std_logic_vector(1 downto 0);
begin

DIVISOR_DE_FRECUENCIA:
process(CLK)
begin
if(CLK'event and CLK='1') then
conta_10ms <= conta_10ms + 1;
if (conta_10ms = 25000) then
CLK_2K <= not CLK_2K;
conta_10ms <= (others =>'0');
end if;
end if;
end process;

CONTADOR_2_BITS:
process(CLK_2K)
begin
if (CLK_2K'event and CLK_2K='1') then
Q <= Q + 1;
end if;
end process;

CONTADOR_2BITS <= Q;

end Behavioral;
Como podemos ver, internamente en este bloque generamos una seal de reloj con frecuencia igual
a 2 KHz, el cual la asignamos a una seal temporal en el cdigo, que a su vez, esta seal la
utilizamos como entrada al siguiente proceso, para as obtener un contador de 2 bits. Como estamos
realizando dos procesos diferentes, es necesario asignarle un nombre a cada proceso para no tener
errores al momento de verificar la sintaxis. Entonces, una vez guardado y compilado este mdulo,
proseguimos con el siguiente.
El siguiente modulo por agregar es un multiplexor, el cual, dependiendo de la entrada de 1 bit, la
visualizacin de los contadores en los displays ser de manera automtica, o de manera manual a
travs de las entradas externas. Este bloque o modulo, consta de dos entradas de dos bits, las
cuales, una ser proveniente del bloque anterior, es decir, del contador de 2 bits, y la otra entrada

Sistemas Embebidos


ser la entrada externa que provendr de los interruptores para seleccionar el tipo de contador y el
respectivo display. Adems de esto, este mdulo tendr una entrada externa de 1 bit, con el cual, a
travs de un interruptor seleccionaremos el modo de trabajo (automtico o manual). Y ya por ltimo,
este bloque tendr una sola salida de dos bits, el cual puede ser cualquiera de las 2 entradas
seleccionadas. El bloque de este mdulo se muestra a continuacin en la figura 6.

Entonces, agregamos un nuevo mdulo a nuestro proyecto y le ponemos el nombre de
mux_modo, y nos debe de quedar de la siguiente manera nuestro cdigo.
fichero mux_modo.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity mux_modo is
Port(ENTRADA_AUTOMATICA: in STD_LOGIC_VECTOR(1 downto 0);
ENTRADA_MANUAL: in STD_LOGIC_VECTOR(1 downto 0);
SELECCION: in STD_LOGIC;
SALIDA_MUX_MODO: out STD_LOGIC_VECTOR(1 downto 0));
end mux_modo;

architecture Behavioral of mux_modo is
begin

WITH SELECCION SELECT
SALIDA_MUX_MODO <= ENTRADA_AUTOMATICA WHEN '0',
ENTRADA_MANUAL WHEN '1',
ENTRADA_MANUAL WHEN OTHERS;
end Behavioral;
Guardamos y compilamos nuestro mdulo y si funciona correctamente proseguimos con el siguiente.
El siguiente mdulo que agregaremos ser un bloque que se encargar de seleccionar el display
correspondiente al contador seleccionado. Este mdulo har la funcin de un demultiplexor, el cual
dependiendo de la seal de entrada, activar una de las salidas correspondientes al display en el

Sistemas Embebidos


que visualizaremos el contador. Para activar un display, necesitamos enviar un 0 lgico a la base del
transistor que controla dicho display. Este bloque, como se muestra en la figura 7, tiene una entrada
de 2 bits (SELEC_DISPLAY), proveniente del bloque de multiplexor de seleccin de modo y tiene
una salida de 4 bits (ACT_DISPLAY), las cuales van conectadas a la base de los transistores que
activan los display.

Analizando este bloque, podemos ver que dependiendo del contador que se seleccione, se
seleccionar tambin el display que queramos activar, de este modo entonces, la entrada de este
bloque ser la misma entrada que la del bloque de contadores. Consecuentemente, cuando se
selecciona el modo de trabajo automtico, trabajan un display y un contador a la vez, pero a una
velocidad muy alta, pasando desapercibido el que los display no siempre estn activos, y por esta
misma razn, ambos bloques van sincronizados a travs de multiplexor de seleccin de modo.
Entonces agregamos un nuevo mdulo VHDL a nuestro proyecto, el cual llamaremos
mux_displays. As pues, el cdigo de este mdulo debe quedar de la siguiente manera.
fichero mux_displays.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity mux_displays is
Port ( SELEC_DISPLAY : in STD_LOGIC_VECTOR(1 downto 3);
ACT_DISPLAY : out STD_LOGIC_VECTOR (0 to 3));
end mux_displays;

architecture Behavioral of mux_displays is
begin
with SELEC_DISPLAY select
ACT_DISPLAY <= "1110" when "00",
"1101" when "01",
"1011" when "10",
"0111" when "11",
"1111" when others;
end Behavioral;

Sistemas Embebidos


Como podemos ver, en la declaracin del vector de salida, tenemos que es (0 to 3), esto es
con el objetivo de facilitar la asignacin de pines a los display, para que as de esta manera,
tengamos que a bit 0 de este vector le corresponda el display AN0, y el bit 3 del vector le
corresponda el display AN3.
Entonces guardamos y verificamos la sintaxis de nuestro modulo. Verificamos que no haya y errores
y proseguimos con nuestro proyecto.
Regresando a la figura 1, podemos ver que hasta aqu, hemos agregado todos los mdulos
necesarios para que funcione como deseamos nuestro proyecto. Ahora lo que sigue es asociar estos
mdulos entre s para que de esta forma queden interconexionados como podemos ver en la figura
1. Para esto, tenemos que crear un nuevo mdulo, y dentro de este mdulo declararemos cada uno
de los componentes (o mdulos) que van a estar dentro y que se van a interconectar entre s. Asi
mismo, tambin dentro de este ltimo modulo que agregaremos, debemos hacer instancias de cada
uno de los submdulos de los que consta el proyecto, es decir, crearemos objetos de cada uno de
los componentes que declaramos y los asociamos con entradas, salidas o seales que se estn
manejando dentro de este mdulo superior.
Volviendo a la figura 1, podemos ver que el recuadro rojo que encierra a todos los bloques,
representa al mdulo donde asociaremos e interconectaremos cada uno de los bloques. Tambin
podemos observar que las entradas y salidas de este mdulo principal, estn en color negro, dado
que representan las entradas externas que provienen de algn componente como interruptor, push
botn, etc. para las entradas; as como tambin para las salidas que van directamente conectados a
algn otro componente como display, led, relevador, etc.
Las lneas internas en color azul, representan las conexiones entre un mdulo y otro; las cuales al
momento de asociarlas dentro de la arquitectura con otras entradas o salidas de otros mdulos,
debemos guardarlas previamente en alguna otra variable temporal, es decir, en una seal, y
despus de esto, esta seal utilizarla como entrada o salida para cualquier otro bloque.
La declaracin de los componentes y seales a utilizar se hace despus de la declaracin de la
arquitectura y antes de la palabra reservada begin, y la creacin de instancias u objetos se hace
despus de la palabra reservada begin. En la siguiente figura (figura 8) se muestra el modulo
principal a manera de bloque, en l podemos apreciar las entradas y salidas que tiene este mdulo.


Sistemas Embebidos


Entonces agregamos el ltimo mdulo a nuestro proyecto, y le ponemos el nombre de
contadores_multiplexados. Agregamos las entradas y salidas necesarias, y nuestro
cdigo de este mdulo debe quedar de la siguiente manera.
Fichero contadores_multiplexados.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity contadores_multiplexados is
Port ( CLK : in STD_LOGIC;
SELECCIONAR_MODO : in STD_LOGIC;
IN_EXTERNA : in STD_LOGIC_VECTOR (1 downto 0);
DISPLAY : out STD_LOGIC_VECTOR (0 to 6);
DISPLAY_ACTIVO : out STD_LOGIC_VECTOR (0 to 3));
end contadores_multiplexados;

architecture Behavioral of contadores_multiplexados is

signal CLK_1SEG : std_logic;
signal SALIDA_CONTADOR : std_logic_vector(3 downto 0);
signal SALIDA_CONTADOR_2BITS : std_logic_vector(1 downto 0);
signal SALIDA_MUXMODO : std_logic_vector(1 downto 0);

component divisor_de_frecuencia
Port (CLK : in STD_LOGIC;
CLK_1S : out STD_LOGIC);
end component;

component counters
Port (CLK_in : in STD_LOGIC;
SELEC_CONTA : in STD_LOGIC_VECTOR (1 downto 0);
OUT_CONTADOR : out STD_LOGIC_VECTOR (3 downto 0));
end component;

component decodificador_7seg
Port (DATO_ENTRADA : in STD_LOGIC_VECTOR (3 downto 0);
SALIDA : out STD_LOGIC_VECTOR (0 to 6));
end component;

component conta_mux
Port (CLK : in STD_LOGIC;
CONTADOR_2BITS : out STD_LOGIC_VECTOR(1 downto 0));
end component;


Sistemas Embebidos


component mux_modo
Port (ENTRADA_AUTOMATICA: in STD_LOGIC_VECTOR(1 downto 0);
ENTRADA_MANUAL: in STD_LOGIC_VECTOR(1 downto 0);
SELECCION: in STD_LOGIC;
SALIDA_MUX_MODO: out STD_LOGIC_VECTOR(1 downto 0));
end component;

component mux_displays
Port (SELEC_DISPLAY : in STD_LOGIC_VECTOR(1 downto 0);
ACT_DISPLAY : out STD_LOGIC_VECTOR (0 to 3));
end component;

begin

objeto_1 : divisor_de_frecuencia
port map ( CLK => CLK,
CLK_1S => CLK_1SEG
);
objeto_2 : conta_mux
port map ( CLK => CLK,
CONTADOR_2BITS => SALIDA_CONTADOR_2BITS
);
objeto_3 : mux_modo
port map ( ENTRADA_AUTOMATICA => SALIDA_CONTADOR_2BITS,
ENTRADA_MANUAL => IN_EXTERNA,
SELECCION => SELECCIONAR_MODO,
SALIDA_MUX_MODO => SALIDA_MUXMODO
);
objeto_4 : counters
port map ( CLK_in => CLK_1SEG,
SELEC_CONTA => SALIDA_MUXMODO,
OUT_CONTADOR => SALIDA_CONTADOR
);
objeto_5 : mux_displays
port map ( SELEC_DISPLAY => SALIDA_MUXMODO,
ACT_DISPLAY => DISPLAY_ACTIVO
);
objeto_6 : decodificador_7seg
port map ( DATO_ENTRADA => SALIDA_CONTADOR,
SALIDA => DISPLAY
);

end Behavioral;
Como podemos ver en el cdigo, para la creacin de instancias (objetos) de un componente, le
asignamos primero un nombre y despus ponemos el nombre del componente del cual vamos a
crear la instancia. Despus de esto viene la asociacin de entradas, salidas y seales. En la

Sistemas Embebidos


declaracin de componentes vimos que declaramos cada uno de los puertos de los que consta el
componente. Para la asociacin de entradas, salidas y seales en la instanciacin de objetos,
debemos de poner todos los puertos de los que consta el componente y as mismo, asociarle algn
otro puerto de entrada o salida, o en su defecto, alguna seal temporal.
Entonces, guardamos y verificamos la sintaxis del mdulo y si funciona compila correctamente sin
problemas, podemos ver ahora como todos los mdulos agregados primero ahora son submdulos
del ultimo modulo que agregamos, como podemos ver a continuacin en la figura 9.

Figura 9.- Submodulos anidados.
Ya por ltimos asociamos los puertos de entrada y salida del mdulo principal a los pines de entrada
y salida de la tarjeta Basys 2. Las entradas las conectaremos a los switches disponibles, y la salidas,
una ser para los segmentos de los display y la otra ser para controlar cada display. En la siguiente
imagen (figura 10) se muestra como se hizo la asignacin de pines.

Figura 10.- Asignacin de puertos a pines de la tarjeta

Sistemas Embebidos


Guardamos el archivo de asociacin de pines y regresamos al ISE Design Suite. En la seccin de
procesos (processes) buscamos la opcin que dice Generating Programming File y damos clic con
el botn derecho. Nos aparece una ventana como la que se muestra a continuacin y en la categora
Startup Options en la primera opcin seleccionamos JTAG Clock y le damos en el botn OK.

Despus damos doble clic en la opcin Generating Programming File y esperamos a que nos genere
el archivo BIT que carguemos en la tarjeta Basys 2. Una vez que se ha generado el archivo *.BIT
ejecutamos el software Adept y cargamos el archivo directamente a la tarjeta. A continuacin se
muestra una foto con la tarjeta funcionando en modo automtico.
Con los switches que asignamos como entradas, seleccionamos el modo de operacin con el
interruptor SW-7, y con los siwtches SW-0 y SW-1 en el modo de trabajo manual introducimos el
contador que queremos visualizar en el display correspondiente.

Funcionamiento en modo automtico de los contadores