1.

-Código utilizado:
Este es el código utilizado para la entidad y la arquitectura:

LIBRARY IEEE;

USE IEEE.STD_LOGIC_1164.all;

ENTITY codifica_boton IS

PORT (piso_donde_va:IN std_logic_vector (2 DOWNTO 0);

codigo_piso:OUT std_logic_vector (1 DOWNTO 0));

END codifica_boton;

ARCHITECTURE arquitectura_cod_boton OF codifica_boton IS

BEGIN

PROCESS (piso_donde_va)

BEGIN

CASE (piso_donde_va) IS

WHEN "001"=> codigo_piso <="00";

WHEN "010"=> codigo_piso <="01";

WHEN "100"=> codigo_piso <="10";

WHEN OTHERS => codigo_piso <="11";

END CASE;

END PROCESS;

END arquitectura_cod_boton;

Este es el código comprueba la funcionalidad del codificador del botón:

LIBRARY ieee;

USE ieee.STD_LOGIC_1164.all;

ENTITY codifica_boton_test IS

END codifica_boton_test;

ARCHITECTURE arquitectura_boton_test OF codifica_boton_test IS

-- Declaración del componente

COMPONENT codifica_boton IS

PORT

piso_donde_va : IN STD_LOGIC_VECTOR (2 DOWNTO 0); -- selección de piso

codigo_piso : OUT STD_LOGIC_VECTOR (1 DOWNTO 0) -- codigo generado

);

END COMPONENT;

-- Declaración de señales

CONSTANT periodo : TIME := 20 ns;

SIGNAL piso_donde_va : STD_LOGIC_VECTOR (2 DOWNTO 0); -- boton que se activa

SIGNAL codigo_piso : STD_LOGIC_VECTOR(1 DOWNTO 0); -- codigo generado

-- Configuración de la arquitectura

BEGIN

boton: codifica_boton PORT MAP (

piso_donde_va => piso_donde_va, -- boton que se activado

codigo_piso => codigo_piso -- codigo generado

);

piso_donde_va <= "100", -- piso 2

"001" AFTER periodo, -- piso 0

"010" AFTER 2 * periodo, -- piso 1

"100" AFTER 3 * periodo, -- piso 2

"000" AFTER 4 * periodo, -- sin marcar piso

"111" AFTER 5 * periodo, -- se aprietan tres botones a la vez

"001" AFTER 6 * periodo, -- piso 0

"100" AFTER 7 * periodo, -- piso 2

"010" AFTER 8 * periodo, -- piso 1

"100" AFTER 9 * periodo, -- piso 2

 "001" AFTER 10 * periodo; -- piso 0

END arquitectura_boton_test;

2.-Capturas de pantallas:

La librería WORK:

La simulación a 200 ns: (sin ampliar)

La simulación a 200 ns: (ampliada)
La simulación a 300 ns: (sin ampliar; para que se vea entera en
pantalla)

3.-Análisis de resultados:
Tras haber creado la entidad y la arquitectura, procedemos a realizar la simulación.
Dicha simulación debe cumplir lo que dice en el archivo de test. Por eso lo
analizaremos por intervalos(cada intervalo son 20 nanosegundos):

1. (piso_donde_va <= "100" )Es decir, el ascensor esta en el piso 2 con el código
de entrada (piso_donde_va) “100”; por lo cual, la salida (codigo_piso) devuelve
“10”.
2. ("001" AFTER periodo) Cuando pasan 20 ns, el código recibe “001” por lo que
devuelve “00” como dice la arquitectura.
3. ("010" AFTER 2 * periodo) Cuando vuelve a pasar un periodo, cambia y recibe
“010” por lo que sale (codigo_piso) es “01”.
4. ("100" AFTER 3 * periodo) cuando pasa el periodo, cambia de piso al segundo
y devuelve en el código_piso “10” como al principio.
5. ("000" AFTER 4 * periodo) como no maraca nada, se recibe “000”; y como es
distinto de: “001”, “010”, “100”; devuelve “11”.
6. ("111" AFTER 5 * periodo) se marcan 3 pisos a la vez y se recibe “111” ”; y
como es distinto de: “001”, “010”, “100”; devuelve “11”.
7. (“001" AFTER 6 * periodo) se aprieta el botón 0 (“001”) y devuelve “00”.
8. (100" AFTER 7 * periodo) ahorase aprieta el botón del segundo piso, por lo que
la salida (código_piso) será “10”
9. ("010" AFTER 8 * periodo) ahora pasa otro periodo y recibe “010” por lo que se
devuelve el equivalente al haber pulsado el botón 1: “01”.
10. (100" AFTER 9 * periodo) Ahora se pulsa el botón del segundo piso y
devolvemos “10”.
11. ("001" AFTER 10 * periodo) por último se requiere bajar al piso 0 y el
código_piso es: “00”.
1.- Primera parte:
a) Código utilizado:
Código de la entidad y arquitectura de un biestable tipo D activado por flanco de
subida y señal clear asíncrona activa a nivel alto: (los comentarios han sido eliminados)

LIBRARY IEEE;

USE ieee.STD_LOGIC_1164.all;

ENTITY biestable_D_con_clr IS

PORT (clock,clear, d: IN STD_LOGIC; q: OUT STD_LOGIC);

END biestable_D_con_clr;

ARCHITECTURE flujo_asin OF biestable_D_con_clr IS

BEGIN

q<= '0' WHEN clear = '1' ELSE d WHEN rising_edge(clock);

END flujo_asin;

b) Capturas:

Este es el campo de trabajo

utilizado para la primera parte de
la práctica con el grupo (17) y los
3 integrantes del mismo.
 Esta es la librería WORK utilizada.
Donde cargamos la entidad y
arquitectura antes que es test.

Esta es la simulación realizada a

50 nanosegundos del test.

El orden de las señales son:

1. Reloj (CLK).
2. Clear.
3. Entrada (D).
4. Salida (Q).
c) Análisis de los resultados:

Lo primero que se observa es la señal de reloj que es periódica, con un periodo

de 8 nanosegundos. Debajo de esta está la señal de clear, que se activa cuando esta
señal vale 1. En esta parte del código (“q<= '0' WHEN clear = '1' ELSE d WHEN
rising_edge(clock);”) se puede ver que el valor de q (la salida) valdra ‘0’ si clear esta a nivel
alto (‘1’) y en el resto de casos, tomará el valor de d (la entrada) cuando el reloj este en
flanco de subida (rising edge en inglés).

Las otras dos señales son la de entrada y la de salida. La de entrada vale cero
en toda la simulación menos en los intervalos: (8ns-10ns), (12ns-13ns), (14ns-23ns),
(24ns-26ns). Como es un biestable activo por flanco de subida, la salida solo se
actualizará cuando el reloj cambie de ‘0’ a ‘1’. Estos casos son:

 4ns: como la entrada es ‘0’, la salida vale 0ns (no varía). La señal de
entrada valdrá 1 entre los 4ns a los 12 ns, pero como no hay flanco de
subida, la salida no se actualiza.
 12ns: como la entrada pasa a valer ‘1’, la salida pasa a valer ‘1’ hasta un
flanco de subida del reloj donde la entrada sea ‘0’.
 20ns: pese a que la entrada ha tomado valores de ‘0’, como en el
vigésimo nanosegundo esta vale ‘1’, la salida seguirá siendo ‘1’.
 28ns: en este flanco de subida la entrada vale ‘0’, y la salida cambiara su
valor a ‘0’.
 36ns: la salida seguirá siendo ‘0’, puesto que este es el valor de la
entrada en estos dos flancos de subida del reloj.
 44ns: la salida seguirá siendo ‘0’, puesto que este es el valor de la
entrada en estos dos flancos de subida del reloj.
2.- Primera parte:
a) Código utilizado:
Código de la entidad y arquitectura de un registro de entradas paralelas, salidas
paralelas y clear asíncrono: (los comentarios han sido eliminados)

LIBRARY IEEE;

USE ieee.STD_LOGIC_1164.all;

ENTITY registro_PP IS

GENERIC (num_bits:natural);

PORT(CLOCK,CLEAR : IN STD_LOGIC;

ent_datos : IN STD_LOGIC_VECTOR ((num_bits - 1) DOWNTO 0);

sal_datos : OUT STD_LOGIC_VECTOR ((num_bits - 1) DOWNTO 0));

END registro_PP;

ARCHITECTURE con_generate OF registro_PP IS

COMPONENT biestable_d_con_clr IS

GENERIC (retardo: TIME:= 0 NS);

PORT (clock,clear, d: IN STD_LOGIC;

Q : OUT STD_LOGIC);

END COMPONENT;

BEGIN

U1:FOR i IN 0 TO (num_bits - 1) GENERATE

B1: biestable_D_con_clr PORT MAP(clock => CLOCK, clear => CLEAR, D => ent_datos(i),
Q => sal_datos(i));

END GENERATE;

END con_generate;
b) Capturas:

Esta es la librería WORK empleada en

la segunda parte de la práctica para el
grupo 17. Se observan los ficheros:

1. BID_GRUPO17.VHD
2. RPP_GENE_GRUPO17.VHD
3. RPP_TB.VHD

Los ficheros utilizados para esta

práctica. El test siempre va el
último. Para la simulación,
daremos clik en el test, luego a
“Set” y antes de darle a
“Aceptar”, marcaremos con un
tick la casilla de “Trace On”.
 Esta es la simulación del test del
Registro. Las señales están
ordenadas:

1. CLOCK (reloj).
2. CLEAR.
3. Entrada.
4. Salida.

Un pequeño “zoom” del 0ns hasta

el 30ns. Para fijarnos mejor como
va cambiando cuando el reloj esta
en flanco de subida.

Esta es la simulación con los datos

de entrada y salida sin minimizar.
Claramente se observa que
minimizados dan lugar a menos
fallos.
c) Análisis de los resultados:
Lo primero que se observa es la señal de reloj que es periódica, con un periodo
de 12 nanosegundos. La segunda señal es la de clear que se activa al nivel alto, es decir
cuando esta vale ‘1’. Clear se activa en el intervalo 52ns al 60ns, haciendo ‘0’ todas las
salidas (“00000”).

Tras esto están la señal de entrada y la señal de salida que posen 5 bits cada
una. La salida tomará los valores de la entrada cuando la señal del reloj esté en flanco
de subida o valdrá “00000” si el clear esta activo (a nivel alto => ‘1’). Los flancos de
subida son:

 6ns: la salida pasa a valer “00001” porque la entrada ha introducido

dichos bits al registro.
 18ns: entrada ha introducido los valores de “00100” y la salida se
actualiza de “00001” a “00100”.
 30ns: la entrada en este flanco toma los valores de “00011” y la salida
actualizara su valor a esto también.
 42ns: la salida tomara el valor de la entrada de ese momento, es decir
“00111”.
 52ns – 60ns: aquí la salida valdrá “00000” porque el clear está activado
(‘1’).
 54ns: la salida vale “00000” porque el clear está activado.
 66ns: como el clear no está activado (está a nivel bajo => ‘0’), la salida
pasará del valor “00000” al valor de la entrada en ese momento
“01111”.
 78ns: la salida vale “11111” como la entrada.
 90ns: seguirá con el valor “11111” porque la entrada no ha varíado en
ese flanco de subida.
1.- Primera parte
MODELADO VHDL DE LA MÁQUINA DE ESTADOS FINITOS (FSM):

a) Código utilizado:
Para esta parte de la práctica hemos creado la entidad y la arquitectura de
comportamiento de la máquina de estados finitos (FSM) del ascensor. Está en el
archivo FSM_ascensor_grupo_17.vhd.

También utilizamos el archivo FSM_ascensor_tb.vhd para probar y ejecutar la

simulación deseada.

b) Capturas de pantallas:

Esta es la librería WORK utilizada

por el grupo 17 para esta es la
parte de la práctica. (Tarea 6)
Para la simulación, colocamos
primero el fichero de la entidad y
arquitectura; y después el fichero
de test; clicamos en el fichero de
test, le damos a set y antes de
darle a aceptar, marcamos con un
tick la casilla de Trace On.

Esta es la simulación con la escala de 2ns

como pedían en la práctica.
Desgraciadamente no cabe en la pantalla.

Esta es la simulación del fichero de test para 200ns con una

escala de 3ns (para ahorrar tamaño). Las señales están
ordenadas como requiere el guión:

1. CLK (la señal de reloj).

2. CODIGO_PISO.
3. SUBE.
4. BAJA.
5. PISO_DONDE_ESTA.
6. E_ACTUAL.
7. E_FUTURO.
c) Tarea-5:
En la simulación se observan siete señales. La primera señal es la señal de reloj
(CLK), que está activo por flanco de subida (pasa de 0 a 1). Tiene un periodo de 20
nanosegundos. Después se observa la señal de entrada CODIGO_PISO que tiene dos
bits y es el código del piso que se pulsa en el ascensor (00 si se desea ir al piso 0; 01 al
piso 1; 10 al piso 2 o 11 si no se pulsan o se pulsan varios botones a la vez; que
entonces no se cambia de piso).

Las siguientes dos señales de salidas son SUBE y BAJA. Sube tomara el valor de
uno cuando el ascensor suba de piso; y baja tomara el valor 0 cuando baje. La señal de
PISO_DONDE_ESTA está compuesta de dos bits y es una señal de entrad, que indica el
piso donde está actualmente el ascensor.

Por último las señales de E_ACTUAL y E_FUTURO queindican el estado actual y

futuro del ascensor. Pueden tomar los valores de piso_0, piso_1 y piso_2.

En la simulación para 25ns:

 La señal de reloj esta a nivel bajo (‘0’), por lo que al no ser un flanco de
subida, no actualizará el estado.
 La señal de codigo_piso vale “00” porque se habrá pulsado el botón del
piso_0 del ascensor.
 La señal de sube esta negada, porque el ascensor no sube de piso
 La señal de baja vale ‘1’, porque el ascensor baja hasta el piso_0.
 La señal de piso_donde_esta vale “11”, porque en el anterior flanco de
subida del reloj, el ascensor seguía en el mismo sitio. Pasará a valer “00”
en el siguiente flanco de subida.
 El e_actual es el piso_2 porque esta en dicho piso. Tomara el valor de
e_futuro en el siguiente flanco.
 E_futuro es piso_0 porque se ha pulsado el botón del piso_0
(codigo_piso = “00”).

En la simulación para 105ns:

 La señal de reloj esta a nivel bajo(‘0’).

 El codigo_piso vale “11” porque se han pulsado varios botones a la vez,
o no sea pulsado ninguno. Por tanto se queda en el mismo piso.
 La señal sube vale cero, porque se queda en el mismo piso.
 La señal baja esta negada, porque el ascensor no baja.
  El piso_donde_esta toma el valor “11” porque el ascensor ni sube ni
baja.
 El estado actual del piso (e_actual) es el piso_2.
 El estado futuro del piso seguirá siendo el mismo piso (piso_2) ya que es
ascensor ni sube ni baja (codigo_piso vale “11”).

d) Tarea-6:

Esta es el contenido de la librería

WORK utilizada por el grupo 17 tras
realizar la simulación. (Tarea 6)
 2.- Segunda parte
MODELADO VHDL DE UN ASCENSOR COMPLETO:

a) Código utilizado:
Para esta parte hemos utilizado el fichero que codifica el botón de un ascensor
(codifica_boton_grupo_17.vhd) de la práctica 1 y el fichero
(FSM_ascensor_grupo_17.vhd) de la primera parte de esta práctica. Tras esto creamos
un fichero llamado ascensor_comple_grupo_17 donde realizamos la entidad y la
arquitectura de estilo estructural de un ascensor completo.

b) Capturas de pantallas:

Esta es la librería WORK utilizada

por el grupo 17 para esta es la
parte de la práctica. (Tarea 8)

Para la simulación, colocamos en

el workspace los ficheros de
codificación de los botones, la
máquina de estados finitos, la
entidad/arquitectura del ascensor
completo y por último el fichero
de test. Clicamos en el fichero de
test, le damos a set y antes de
darle a aceptar, marcamos con un
tick la casilla de Trace On.
 Esta es la simulación del fichero test del ascensor
completo (ascensor_completo_tb.vhd) Hemos
simulado 200ns, pero hemos puesto una escala de
3ns en vez de 2ns, para que nos cupiese en la
pantalla.

c) Tarea-7:
En la señal se observan 8 señales. La primera es la señal de reloj, que se activa
por flanco de subida (pasar de ‘0’ a ‘1’) y tienen un periodo de 10 nanosegundos. La
segunda señal es el piso_donde_va, que es una señal de entrada de tres bits. Luego
está la última señal de entrada que es el codigo_piso que es una señal compuesta de 2
bits. El resto de señales son señales de salida, donde piso_donde_esta, que recibe los
dos bits del codigo_del_piso; también están las señales de estado (e_actual y
e_futuro), que indica el piso donde está por la enumeración de piso_0, piso_1 o piso_2
y las últimas señales son la de sube y baja, que si están activadas (‘1’), entonces el
ascensor subirá o bajará respectivamente.

Se observa que en la simulación todo ocurre sin errores. El fichero test da los
valores de entrada y gracias a los demás ficheros, procesan la información y devuelven
una salida. Por ejemplo en el 65ns, tiene ciertos valores de entrada, y que en el
nanosegundo 70 (flanco de subida del reloj), se actualizan correctamente el
piso_donde_esta, el estado actual, toma el valor del futuro etc…
d) Tarea-8:

Esta es la librería WORK utilizada

por el grupo 17 tras realizar la
simulación del codificador del
ascensor completo.