PRCTICAS DE ESTRUCTURA Y TECNOLOGA DE COMPUTADORES III

Nombre: Jacobo Domnguez

ACTIVIDAD VOLUNTARIA 1: INTRODUCCIN AL MANEJO DEL SIMULADOR (I).............2 ACTIVIDADES COMPLEMENTARIAS ...........................................................................................................2 CDIGO VHDL ........................................................................................................................................2 ACTIVIDAD VOLUNTARIA 2: INTRODUCCIN AL MANEJO DEL SIMULADOR (II) ...........4 ACTIVIDADES COMPLEMENTARIAS ..........................................................................................................4 CDIGO VHDL ........................................................................................................................................5 ACTIVIDAD VOLUNTARIA 3: INTRODUCCIN AL MANEJO DEL SIMULADOR (III)..........6 CDIGO VHDL ........................................................................................................................................6 ACTIVIDAD VOLUNTARIA 4: USO DEL DEPURADOR..................................................................8 CDIGO VHDL ........................................................................................................................................8 PRCTICA OBLIGATORIA 1: DISEO ALGORTMICO DE UNA ALU DE 4BITS ...................9 DEFINICIN DE LA ENTIDAD .....................................................................................................................9 MODELO ALGORTMICO ............................................................................................................................9 PRUEBA DEL CIRCUITO .............................................................................................................................9 CDIGO VHDL.........................................................................................................................................10 PRCTICA OBLIGATORIA 2: DISEO ESTRUCTURAL DE UN REGISTRO DE DESPLAZAMIENTO DE 4 BITS...........................................................................................................13 DEFINICIN DE LA ENTIDAD ...................................................................................................................13 MODELO ESTRUCTURAL .........................................................................................................................13 PRUEBA DEL CIRCUITO ...........................................................................................................................13 CDIGO VHDL ......................................................................................................................................14 PRCTICA OBLIGATORIA 3: DISEO ESTRUCTURAL DE UN REGISTRO DE DESPLAZAMIENTO DE N BITS..........................................................................................................17 DEFINICIN DE LA ENTIDAD ...................................................................................................................17 MODELO ESTRUCTURAL .........................................................................................................................17 PRUEBA DEL CIRCUITO ...........................................................................................................................18 CDIGO VHDL ......................................................................................................................................19 PRCTICA OBLIGATORIA 4 ..............................................................................................................21 DEFINICIN DE LA ENTIDAD ...................................................................................................................21 MODELO ESTRUCTURAL .........................................................................................................................21 Diagrama de flujos (autmata de Moore) ........................................................................................22 Tabla de Estados...............................................................................................................................22 Codificacin de los estados y de las entradas ..................................................................................23 Tabla de Transiciones y de excitacin ..............................................................................................23 Ecuaciones de entrada a los biestables ............................................................................................23 Esquema estructura del circuito secuencial resultante.....................................................................24 PRUEBAS DEL CIRCUITO..........................................................................................................................25 CDIGO VHDL ......................................................................................................................................25 CONCLUSIONES OPINIONES Y MEJORAS.....................................................................................30

ACTIVIDAD VOLUNTARIA 1: MANEJO DEL SIMULADOR (I)

INTRODUCCIN

AL

Siguiendo los pasos escritos en el guin de la prctica creamos el modelo de un inversor y comprobamos su funcionamiento. Podemos ver los resultados del simulador en la siguiente grfica, adjuntamos el cdigo VHDL al final de esta actividad.

Actividades complementarias
El almacenamiento de la simulacin en ficheros se realiza mediante la opcin Ascii Output y podemos abrirlo con cualquier visor de texto. El formato que utiliza es mediante etiquetas donde describe la fecha, la versin, la escala temporal, el mdulo simulador, las seales que exportamos, y el conjunto de datos resultado de la simulacin. Se puede ver el fichero en \Actividad1\wavedump.txt. Posee diferentes utilidades de zoom, y mediante un cursor podemos observar a la izquierda el valor de las seales.

Adems posee la opcin de aadir un par de cursores que nos proporcionan informacin respecto a la diferencia de tiempo entre ellos. Para no tener que especificar la configuracin del inversor en puerba_inversor_arq1.vhd, es necesario utilizar el mismo nombre para el componente que el de la entidad. Creamos otra arquitectura, prueba_inversor_arq2.vhd donde no especificamos la configuracin del inversor, mostramos los cambios realizados:
... COMPONENT inversor PORT(x:IN BIT; y:OUT BIT); END COMPONENT; ... puerta1 : inversor PORT MAP (entrada, salida);

Cdigo VHDL
-- inversor.vhd ENTITY inversor IS PORT(x:IN BIT; y:OUT BIT); END inversor;

--inversor_arq1.vhd ARCHITECTURE arquitectura1 OF inversor IS BEGIN PROCESS BEGIN y <= NOT x; WAIT ON x; END PROCESS; END arquitectura1;

-- prueba_inversor.vhd ENTITY prueba_inversor IS END prueba_inversor; -- prueba_inverosor_arq1.vhd ARCHITECTURE arquitectura1 OF prueba_inversor IS COMPONENT puerta PORT(x:IN BIT; y:OUT BIT); END COMPONENT; FOR puerta1 : puerta USE ENTITY WORK.inversor(arquitectura1); SIGNAL entrada, salida: BIT; BEGIN puerta1 : puerta PORT MAP (entrada, salida); entrada <= '1' AFTER 3 ns, '0' AFTER 6 ns, '1' AFTER 9 ns, '0' AFTER 11 ns, '1' AFTER 13 ns, '0' AFTER 15 ns, '1' AFTER 17 ns, '0' AFTER 20 ns, '1' AFTER 23 ns, '0' AFTER 26 ns; END arquitectura1; -- prueba_inversor_arq2.vhd ARCHITECTURE arquitectura2 OF prueba_inversor IS COMPONENT inversor PORT(x:IN BIT; y:OUT BIT); END COMPONENT; SIGNAL entrada, salida: BIT; BEGIN puerta1 : inversor PORT MAP (entrada, salida); entrada <= '1' AFTER 3 ns, '0' AFTER 6 ns, '1' AFTER 9 ns, '0' AFTER 11 ns, '1' AFTER 13 ns, '0' AFTER 15 ns, '1' AFTER 17 ns, '0' AFTER 20 ns, '1' AFTER 23 ns, '0' AFTER 26 ns; END arquitectura2;

ACTIVIDAD VOLUNTARIA 2: MANEJO DEL SIMULADOR (II)

INTRODUCCIN

AL

Siguiendo los pasos descritos en la gua de las prcticas obtenemos la simulacin con el inversor con 1 ns de retraso.

Utilizando el retardo inercial de 5ns obtenemos:

Y finalmente, con el transpor de 5ns:

Actividades Complementarias
1. Si eliminamos el WAIT ON x del inversor se produce un error de compilacin ya que el proceso no posee una lista de sensibilizacin de seales:
8: END PROCESS; ^ [Warning] Current process has no sensitivity list and no wait statement

2. El retardo inercial no transmite a la salida cambios en la seal menores en duracin al valor que hemos fijado. El retardo transport lleva a la salida el valor de la entrada retrasado con el valor que hemos fijado. 3. La opcin trace en el men simulate es similar al trace on, pero en este caso seleccionas las seales de las que quieres obtener una traza. 4. Si fijamos el retardo de la puerta a un valor inercial de 4ns, el resultado es el mismo que el del caso con 5ns, ya que el driver de entrada solo se mantiene a un valor dado como mximo 3 ns entre transiciones. 5. Si reinicializamos la librera se borran todas las entidades y sus arquitecturas ya compiladas. Si cambiamos el orden de compilacin, el error nos informa que no puede compilar una arquitectura de la que no tiene definida una entidad, ya que no ha sido compilada todava y no est en la librera. La solucin es compilar siempre las definiciones de entidades antes que las definiciones de arquitecturas.

Cdigo VHDL
-- inverosr.vhd ENTITY inversor IS PORT(x:IN BIT; y:OUT BIT); END inversor; -- inversor_arq2.vhd ARCHITECTURE arquitectura2 OF inversor IS BEGIN PROCESS BEGIN y <= NOT x AFTER 1 ns; -- y <= INERTIAL NOT x AFTER 5 ns; -- y <= TRANSPORT NOT x AFTER 5 ns; WAIT ON x; END PROCESS; END arquitectura2; -- prueba_inversor.vhd ENTITY prueba_inversor IS END prueba_inversor; -- prueba_inversor_arq2.vhd ARCHITECTURE arquitectura2 OF prueba_inversor IS COMPONENT puerta PORT(x:IN BIT; y:OUT BIT); END COMPONENT; SIGNAL entrada, salida: BIT; BEGIN puerta1 : puerta PORT MAP (entrada, salida); entrada <= '1' AFTER 3 ns, '0' AFTER 6 ns, '1' AFTER 9 ns, '0' AFTER 11 ns, '1' AFTER 13 ns, '0' AFTER 15 ns, '1' AFTER 17 ns, '0' AFTER 20 ns, '1' AFTER 23 ns, '0' AFTER 26 ns; END arquitectura2; -- prueba_config1.vhd CONFIGURATION config1 OF prueba_inversor IS FOR arquitectura2 FOR puerta1: puerta USE ENTITY WORK.inversor(arquitectura2); END FOR; END FOR; END config1;

ACTIVIDAD VOLUNTARIA 3: MANEJO DEL SIMULADOR (III)

INTRODUCCIN

AL

Creamos la etapa de inversores, utilizando un modelado estructural a partir del inversor que venimos utilizando en las actividades anteriores. Tras seguir los pasos del guin obtenemos la misma simulacin que se describe en el.

1. Para almacenar los resultados en un fichero ASCII, utilizamos la opcin ASCII OUTPUT, que aparece, entre otras, al pulsar el botn derecho del ratn sobre las trazas de las seales de la simulacin. 2. Para especificar en otro fichero la configuracin eliminamos, creamos una nueva arquitectura sin especificarla. En el fichero de configuracin escribimos:
CONFIGURATION conf1 OF prueba_etapa IS FOR arq2 FOR circuito1 : circuito USE ENTITY WORK.etapa_inversores(arq1); END FOR; END FOR; END conf1;

3. No es necesario definir la configuracin del inversor en el fichero etapa_arq1.vhd, por que el componente posee el mismo nombre que la entidad, y esta solo tiene una arquitectura. 4. Si el nombre del componente no coincide con el de la entidad y no especificamos la configuracin obtenemos el siguiente warning, por cada puerta creada, a la hora de simular:
Warning: <300c6> During elaboration. Could not create a default entity aspect for for-generated block :PRUEBA_ETAPA(ARQ2):CIRCUITO1@ ETAPA_INVERSORES(ARQ1):GEN(0). At line 7, of file D:\UNED\VHDL\ACTIVIDAD3\ETAPA_ARQ1.VHD. No entity named PUERTA was found

Esto es debido a que el simulador no encuentra una entidad apropiada para el componente que utilizamos.

Cdigo VHDL
-- inversor.vhd ENTITY inversor IS PORT(x:IN BIT; y:OUT BIT); END inversor; -- inversor_arq1.vhd ARCHITECTURE arquitectura1 OF inversor IS BEGIN PROCESS

BEGIN y <= NOT x; WAIT ON x; END PROCESS; END arquitectura1;

-- etapa.vhd ENTITY etapa_inversores IS PORT (entradas: IN bit_vector (7 downto 0); salidas : OUT bit_vector (7 downto 0)); END etapa_inversores; -- etapa_arq1.vhd ARCHITECTURE arq1 OF etapa_inversores IS COMPONENT inversor PORT(x:IN BIT; y:OUT BIT); END COMPONENT; BEGIN gen : FOR I IN 0 TO 7 GENERATE puerta:inversor PORT MAP(entradas(I),salidas(I)); END GENERATE gen; END arq1;

-- Prueba_etapa.vhd ENTITY prueba_etapa is END prueba_etapa; -- prueba_etapa_arq1.vhd ARCHITECTURE arq1 OF prueba_etapa IS COMPONENT circuito PORT (entradas : IN bit_vector (7 downto 0); salidas : OUT bit_vector (7 downto 0)); END COMPONENT; FOR ALL : circuito USE ENTITY WORK.etapa_inversores(arq1); SIGNAL entradas, salidas: bit_vector (7 downto 0); BEGIN circuito1 : circuito PORT MAP (entradas, salidas); entradas <= "10101010" AFTER 5 ns, "01010101" AFTER 10 ns, "11110000" AFTER 15 ns, "11110000" AFTER 20 ns, "11110000" AFTER 25 ns, "00001111" AFTER 30 ns, "10000001" AFTER 35 ns; END arq1; -- prueba_etapa_arq2.vhd ARCHITECTURE arq2 OF prueba_etapa IS COMPONENT circuito PORT (entradas : IN bit_vector (7 downto 0); salidas : OUT bit_vector (7 downto 0)); END COMPONENT; SIGNAL entradas, salidas: bit_vector (7 downto 0); BEGIN circuito1 : circuito PORT MAP (entradas, salidas); entradas <= "10101010" AFTER 5 ns, "01010101" AFTER 10 ns, "11110000" AFTER 15 ns, "11110000" AFTER 20 ns, "11110000" AFTER 25 ns, "00001111" AFTER 30 ns, "10000001" AFTER 35 ns; END arq2; -- prueba_conf1.vhd CONFIGURATION conf1 OF prueba_etapa IS FOR arq2 FOR circuito1 : circuito USE ENTITY WORK.etapa_inversores(arq1); END FOR; END FOR; END conf1;

ACTIVIDAD VOLUNTARIA 4: USO DEL DEPURADOR

Siguiendo los pasos del guin, no se encuentra ningn problema con la realizacin de esta actividad voluntaria.

Cdigo VHDL
-- El cdigo es el mismo que el de la actividad voluntaria 3.

PRCTICA OBLIGATORIA 1: DISEO ALGORTMICO DE UNA ALU DE 4BITS

Definicin de la entidad
La definicin de la entidad sigue las especificaciones dadas en la memoria:
ENTITY alu4 IS PORT( B: IN std_logic_vector(3 downto 0); A: IN std_logic_vector(3 downto 0); s1: IN std_ulogic; s0: IN std_ulogic; c: IN std_ulogic; Z: OUT std_logic_vector(3 downto 0)); END alu4;

Modelo algortmico
El modelo algortmico utiliza dos funciones, que estn definida en el libro base de la asignatura (pag 190,191) bin_ent y ent_bin, que convierten un valor de binario a entero y de entero a binario respectivamente.
control:=s1&s0&c; ai:=bin_ent(A); bi:=bin_ent(B); aux:=NOT B; nbi:=bin_ent(aux); CASE control IS WHEN "000" => zi:=ai+bi; WHEN "001" => zi:=ai+bi+1; WHEN "010" => zi:=ai+nbi; -- resta A y B con arrastre WHEN "011" => zi:=ai+nbi+1; -- resta A y B WHEN "100" => zi:=ai; WHEN "101" => zi:=ai+1; WHEN "110" => zi:=ai-1; WHEN "111" => zi:=0; WHEN OTHERS => NULL; END CASE; Z<=ent_bin(zi);

Una vez convertidos los valores se operan dependiendo de la seal de control.

Prueba del circuito

Para realizar las pruebas realizamos todas las operaciones posibles en la arquitectura de la entidad de prueba.
puerta1 : puerta PORT MAP(B,A,control(2),control(1),control(0),Z); A<="0011"; B<="0011"; ---- cada 5 ns paso a probar la siguiente operacin de la alu control<= "000", -- suma A y B "001" AFTER 5 ns, -- suma A y B con arrastre "010" AFTER 10 ns,-- resta A y B con arrastre "011" AFTER 15 ns,-- resta A y B "100" AFTER 20 ns,-- transfiere A "101" AFTER 25 ns,-- incrementa A en 1 "110" AFTER 30 ns,-- decrementa A en 1 "111" AFTER 35 ns;-- coloca la salida a ceros

Los resultados de las simulaciones se pueden ver en el siguiente grfico.

Se puede ver como funciona correctamente en todos los casos posibles: A) B) C) D) E) F) G) H) Control 000 A=0011=3 ,B=0011=3,Z=A+B=0110 Control 001 Z=A+B+1=0111 Control 010 Z=A+B=1111 Control 011 Z=A+B+1=0000 Control 100 Z=A=0011 Control 101 Z=A+1=0100 Control 110 Z=A-1=0010 Control 111 Z=0000 =6 =7 =15 =0 =3 =4 =2 =0

Cdigo vhdl.
-- alu4.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY alu4 IS PORT( B: IN std_logic_vector(3 downto 0); A: IN std_logic_vector(3 downto 0); s1: IN std_ulogic; s0:IN std_ulogic; c:IN std_ulogic; Z: OUT std_logic_vector(3 downto 0)); END alu4; --- alu4_arq1.vhd ARCHITECTURE arquitectura1 OF alu4 IS BEGIN PROCESS(B,A,c,s1,s0) -- funcin que convierte de binario a entero, pag 190 FUNCTION bin_ent (v:std_logic_vector) RETURN integer IS VARIABLE int_var : integer:=0; BEGIN FOR i IN 0 TO 3 LOOP IF(v(i)='1') THEN int_var:=int_var+(2**i); END IF; END LOOP; RETURN int_var;

10

END bin_ent; --funcin que convierte de entero a binario, pag 191 FUNCTION ent_bin(e:integer) RETURN std_logic_vector IS VARIABLE int_var: std_logic_vector(3 DOWNTO 0); VARIABLE temp1 : integer := 0; VARIABLE temp2 : integer := 0; BEGIN temp1:=e; FOR i IN 3 DOWNTO 0 LOOP temp2:=temp1/(2**i); temp1:=temp1 mod (2**i); IF ( temp2=1) THEN int_var(i):='1'; ELSE int_var(i):='0'; END IF; END LOOP; RETURN int_var; END ent_bin; ----------------------------------------------------------------VARIABLE control : std_ulogic_vector(2 DOWNTO 0); VARIABLE ai,bi,nbi,zi: integer; VARIABLE aux: std_logic_vector(3 DOWNTO 0); BEGIN control:=s1&s0&c; ai:=bin_ent(A); bi:=bin_ent(B); aux:=NOT B; nbi:=bin_ent(aux); CASE control IS WHEN "000" => zi:=ai+bi; WHEN "001" => zi:=ai+bi+1; WHEN "010" => zi:=ai+nbi; -- resta A y B con arrastre WHEN "011" => zi:=ai+nbi+1; -- resta A y B WHEN "100" => zi:=ai; WHEN "101" => zi:=ai+1; WHEN "110" => zi:=ai-1; WHEN "111" => zi:=0; WHEN OTHERS => NULL; END CASE; Z<=ent_bin(zi); END PROCESS; END arquitectura1; --- testalu4.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY testalu4 IS END testalu4; ---------------------------------------------------------ARCHITECTURE arquitectura1 OF testalu4 IS COMPONENT puerta PORT( B: IN std_logic_vector(3 downto 0); A: IN std_logic_vector(3 downto 0); s1: IN std_ulogic; s0:IN std_ulogic; c:IN std_ulogic; Z: OUT std_logic_vector(3 downto 0)); END COMPONENT; FOR puerta1 : puerta USE ENTITY WORK.alu4(arquitectura1); SIGNAL A,B,Z : std_logic_vector(3 DOWNTO 0); SIGNAL control: std_ulogic_vector(2 DOWNTO 0); BEGIN puerta1 : puerta PORT MAP(B,A,control(2),control(1),control(0),Z); A<="0011";

11

B<="0011"; ---- cada 5 ns paso a probar la siguiente operacin de la alu control<= "000", -- suma A y B "001" AFTER 5 ns, -- suma A y B con arrastre "010" AFTER 10 ns,-- resta A y B con arrastre "011" AFTER 15 ns,-- resta A y B "100" AFTER 20 ns,-- transfiere A "101" AFTER 25 ns,-- incrementa A en 1 "110" AFTER 30 ns,-- decrementa A en 1 "111" AFTER 35 ns;-- coloca la salida a ceros END arquitectura1;

12

PRCTICA OBLIGATORIA 2: DISEO ESTRUCTURAL DE UN REGISTRO DE DESPLAZAMIENTO DE 4 BITS

Definicin de la entidad
La definicin de la entidad queda como sigue:
ENTITY r4 IS PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector(3 downto 0); EI : IN std_ulogic; Q : OUT std_ulogic_vector(3 downto 0)); END r4;

Con esta definicin de entidad cumplimos todas las especificaciones dadas en el enunciado de la gua de estas prcticas.

Modelo estructural
Una vez tenemos definidos los biestables D y los multiplexores, la definicin estructural de la arquitectura del registro desplazamiento es sencilla. Utilizamos el modelo algortmico que aparece en el libro para los biestables D, activos con flanco de subida. Los multiplexores conectan a la salida la seal de entrada definida por el valor de control (0,1,2,3). El modelo estructural se resume en:
mux3 : multi41 PORT MAP(E(3),ED ,qs(2),qs(3),c2,c1,ms(3)); mux2 : multi41 PORT MAP(E(2),qs(3),qs(1),qs(2),c2,c1,ms(2)); mux1 : multi41 PORT MAP(E(1),qs(2),qs(0),qs(1),c2,c1,ms(1)); mux0 : multi41 PORT MAP(E(0),qs(1),EI ,qs(0),c2,c1,ms(0)); gen : FOR I IN 3 DOWNTO 0 GENERATE bi : biestableD PORT MAP(reloj,ms(I),qs(I)); END GENERATE; Q<=qs;

Utilizamos una seal auxiliar de interconexin qs, para realimentar las salidas a las entradas. Respecto a los biestables es sencillo instanciarlos mediante una sentencia generate, dada su estructura regular. Como se ve la seal auxiliar ms nos permite interconectar los biestables y los multiplexores.

Prueba del circuito

13

Las diferentes operaciones que se pueden ver en el grfico anterior son cuatro, dependiendo de los valores de la seal de control, y son todas las operaciones que puede realizar la ALU: ED = 1, EI = 0 A) Control (C2,C1)=11 B) Control (C2,C1)=10 CARGA salida(t+1)=0110=entrada(t)=0110; LDAS salida(t) = 0110 1011 1101 1110 1111 LIAS salida(t) = 1110 1100 1000 0000 0000

C) Control (C2,C1)=01

D) Control (C2,C1)=00

NOP

salida(t) =

Como se puede ver funciona correctamente en todos los casos, y cada instante t+1, viene definido mediante los flancos positivos del reloj.

Cdigo VHDL
-- biestableD.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY biestableD IS PORT( reloj : IN bit; entrada: IN std_ulogic; salida : OUT std_ulogic); END biestableD; -- biestable_arq1.vhd ARCHITECTURE arq1 OF biestableD IS BEGIN PROCESS(reloj) -- sensible al reloj BEGIN IF (reloj='1') AND(reloj'EVENT) THEN salida<=entrada; END IF; END PROCESS; END arq1;

-- multi41.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY multi41 IS PORT( e3,e2,e1,e0 : IN std_ulogic; c2,c1 : IN std_ulogic; salida : OUT std_ulogic); END multi41; -- multi41_arq1.vhd ARCHITECTURE arq1 OF multi41 IS BEGIN PROCESS(e3,e2,e1,e0,c2,c1) -- sensible a la entrada y el control VARIABLE control : std_ulogic_vector(1 DOWNTO 0); BEGIN control:=c2&c1; CASE control IS

14

WHEN "00" => salida<=e0; WHEN "01" => salida<=e1; WHEN "10" => salida<=e2; WHEN "11" => salida<=e3; WHEN OTHERS => NULL; END CASE; END PROCESS; END arq1; -- r4.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY r4 IS PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector(3 downto 0); EI : IN std_ulogic; Q : OUT std_ulogic_vector(3 downto 0)); END r4; -- r4_arq1.vhd ARCHITECTURE arq1 OF r4 IS -- declaracin de seales de interconexin SIGNAL qs : std_ulogic_vector(3 downto 0); SIGNAL ms : std_ulogic_vector(3 downto 0); -- definimos el componente del multiplexor COMPONENT multi41 PORT( e3,e2,e1,e0 : IN std_ulogic; c2,c1 : IN std_ulogic; salida : OUT std_ulogic); END COMPONENT; -- definimos el componente del biestable COMPONENT biestableD PORT( reloj : IN bit; entrada: IN std_ulogic; salida : OUT std_ulogic); END COMPONENT; -- instaciacin de componentes BEGIN mux3 : multi41 PORT MAP(E(3),ED ,qs(2),qs(3),c2,c1,ms(3)); mux2 : multi41 PORT MAP(E(2),qs(3),qs(1),qs(2),c2,c1,ms(2)); mux1 : multi41 PORT MAP(E(1),qs(2),qs(0),qs(1),c2,c1,ms(1)); mux0 : multi41 PORT MAP(E(0),qs(1),EI ,qs(0),c2,c1,ms(0)); gen : FOR I IN 3 DOWNTO 0 GENERATE bi : biestableD PORT MAP(reloj,ms(I),qs(I)); END GENERATE; Q<=qs; END arq1; -- testr4.vhd USE WORK.ALL; LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY prueba_generica IS END prueba_generica; ARCHITECTURE arquitectura OF prueba_generica IS -- Declaracin del componente a probar. COMPONENT registro PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector(3 downto 0); EI : IN std_ulogic;

15

Q: OUT std_ulogic_vector(3 downto 0)); END COMPONENT; -- Especificacin de configuracin, salvo que recurra a declaracin de configuracin FOR ALL : registro USE ENTITY r4(arq1);

CONSTANT duracion_ciclo: TIME:=5ns; SIGNAL CLK_s:BIT:='0'; -- Declaracin de seales de entrada y salida del componente a probar. SIGNAL c2:std_ulogic:='0'; SIGNAL c1:std_ulogic:='0'; SIGNAL ED:std_ulogic:='0'; SIGNAL EI:std_ulogic:='0'; SIGNAL entrada:std_ulogic_vector(3 downto 0); SIGNAL salida: std_ulogic_vector(3 downto 0); BEGIN -- instanciacin del componente a probar registro1 : registro PORT MAP(CLK_s,c2,c1,ED,entrada,EI,salida); reloj : PROCESS BEGIN WAIT FOR duracion_ciclo; CLK_s <= '1'; WAIT FOR duracion_ciclo; CLK_s <= '0'; END PROCESS reloj; pruebas : PROCESS BEGIN --- Asignacin de valores a las seales de entrada del componente a probar. -ED <= '1'; EI <= '0'; entrada <= "0110"; -- CARGA , LDAS , LIAS c2 <= '1' , '1' AFTER 12ns,'0' AFTER 52ns; c1 <= '1' , '0' AFTER 12ns,'1' AFTER 52ns, '0' AFTER 100ns; WAIT; END PROCESS pruebas; END arquitectura;

16

PRCTICA OBLIGATORIA 3: DISEO ESTRUCTURAL DE UN REGISTRO DE DESPLAZAMIENTO DE n BITS

Definicin de la entidad
La definicin de la entidad ahora aade un parmetro genrico que define el nmero de bits de las seales de entrada y salida. Este parmetro es el nmero de ALU de 4 bits que se usarn, por lo tanto el nmero de bits de las seales de E y Q son 4*magnitud, que es el rango (4*magnitud-1 DOWNTO 0).
LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY desplazamiento_n IS GENERIC(magnitud: natural:=2); PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector((4*magnitud-1) downto 0); EI : IN std_ulogic; Q : OUT std_ulogic_vector((4*magnitud-1) downto 0)); END desplazamiento_n;

Modelo estructural
El modelo estructural utiliza el componente creado en la actividad anterior para instanciar, mediante la sentencia generate, el nmero de registros de 4 bits especificados por magnitud.
desplazamiento : FOR I IN magnitud DOWNTO 1 GENERATE menos_sig :IF I=magnitud GENERATE primero : r4 PORT MAP(reloj,c2,c1,ED, E(4*I-1 downto 4*(I-1)),qs(2*I-1),qs(4*I-1 downto 4*(I-1))); END GENERATE menos_sig; media_sig : IF I>1 AND I<2 GENERATE medios : r4 PORT MAP(reloj,c2,c1,qs(2**I), E(4*I-1 downto 4*(I-1)),qs(2**I-1),qs(4*I-1 downto 4*(I-1))); END GENERATE media_sig; mas_sig : IF I=1 GENERATE ultimo : r4 PORT MAP(reloj,c2,c1,qs(4), E(3 downto 0),EI,qs(3 downto 0)); END GENERATE mas_sig; END GENERATE desplazamiento; Q<=qs;

Se utiliza igual que antes una seal auxiliar para realimentar las salidas de los biestables. La interconexin no resulta sencilla ya que tenemos tres casos posibles: Registro ms significativo I=magnitud: Se conecta el puerto ED a el. Los puertos E y Q corresponde con los 4 puertos mayores: E(4*I-1 downto 4*(I-1) qs(4*I-1 downto 4*(I-1) El puerto EI debe ser conectado a la salida del siguiente registro: qs(2*I-1)

17

Registros intermedios, I: Se conecta el puerto ED a la salida del registro anterior: qs(2**I) Los puertos E y Q corresponde con los 4 puertos intermedios: E(4*I-1 downto 4*(I-1) qs(4*I-1 downto 4*(I-1) El puerto EI debe ser conectado a la salida del siguiente registro: qs(2**I-1) Registro menos significativo I=1: Se conecta el puerto ED a la salida del registro superior. qs(4) Los puertos E y Q corresponde con los 4 puertos menores: E(3 downto 0) qs(3 downto 0) El puerto EI de este registro, se conecta simplemente al puerto EI: EI

Prueba del circuito

Los resultados son similares a la prctica anterior pero ahora operando con 8bits: ED = 1, EI = 0 E) (c2,c1)=11 F) (c2,c1)=10 CARGA LDAS salida(t+1)=01101011=entrada(t)=01101011; salida(t) = 01101011 10110101 . 11111111 (85ns)

18

G) Control (C2,C1)=01

LIAS

salida(t) =

11111111 11111110 00000000 0000

H) Control (C2,C1)=00

NOP

salida(t) =

Como se puede ver funciona correctamente en todos los casos, y cada instante t+1, viene definido mediante los flancos positivos del reloj.

Cdigo VHDL
-- UTILIZAMOS EL MISMO CODIGO DE LA PRCTICA OBLIGATORIA 3, DEL -- BIESTABLE D, MULTI41, Y R4.
--rn.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY desplazamiento_n IS GENERIC(magnitud: natural:=2); PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector((4*magnitud-1) downto 0); EI : IN std_ulogic; Q : OUT std_ulogic_vector((4*magnitud-1) downto 0)); END desplazamiento_n;

-- rn_arq1.vhd ARCHITECTURE arq1 OF desplazamiento_n IS -- declaracin de seales de interconexin --seales entre los registros SIGNAL qs : std_ulogic_vector(4*magnitud-1 downto 0); -- definimos el componente del registro COMPONENT r4 PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector(3 downto 0); EI : IN std_ulogic; Q : OUT std_ulogic_vector(3 downto 0)); END COMPONENT; -- especificaciones de configuracin

-- instaciacin de componentes BEGIN desplazamiento : FOR I IN magnitud DOWNTO 1 GENERATE menos_sig : IF I=magnitud GENERATE primero : r4 PORT MAP(reloj,c2,c1,ED, E(4*I-1 downto 4*(I-1)),qs(2*I-1),qs(4*I-1 downto 4*(I-1))); END GENERATE menos_sig; media_sig : IF I>1 AND I<2 GENERATE medios : r4 PORT MAP(reloj,c2,c1,qs(2**I), E(4*I-1 downto 4*(I-1)),qs(2**I-1),qs(4*I-1 downto 4*(I-1))); END GENERATE media_sig;

19

mas_sig : IF I=1 GENERATE ultimo : r4 PORT MAP(reloj,c2,c1,qs(4), E(3 downto 0),EI,qs(3 downto 0)); END GENERATE mas_sig; END GENERATE desplazamiento; Q<=qs; END arq1;

-- testRn.vhd USE WORK.ALL; LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY prueba_desplazamiento8 IS END prueba_desplazamiento8; ARCHITECTURE arquitectura OF prueba_desplazamiento8 IS -- Declaracin del componente a probar. COMPONENT desplazamiento_n GENERIC(magnitud:natural:=2); PORT( reloj: IN bit; c2 : IN std_ulogic; c1 : IN std_ulogic; ED : IN std_ulogic; E : IN std_ulogic_vector(4*magnitud-1 downto 0); EI : IN std_ulogic; Q: OUT std_ulogic_vector(4*magnitud-1 downto 0)); END COMPONENT; -- Especificacin de configuracin, salvo que recurra a declaracin de configuracin CONSTANT duracion_ciclo: TIME:=5ns; SIGNAL CLK_s:BIT:='0'; -- Declaracin de seales de entrada y salida del componente a probar. SIGNAL c2:std_ulogic:='0'; SIGNAL c1:std_ulogic:='0'; SIGNAL ED:std_ulogic:='0'; SIGNAL EI:std_ulogic:='0'; SIGNAL entrada:std_ulogic_vector(7 downto 0); SIGNAL salida: std_ulogic_vector(7 downto 0); BEGIN -- instanciacin del componente a probar reg8 : desplazamiento_n GENERIC MAP(2) PORT MAP(CLK_s,c2,c1,ED,entrada,EI,salida); reloj : PROCESS BEGIN WAIT FOR duracion_ciclo; CLK_s <= '1'; WAIT FOR duracion_ciclo; CLK_s <= '0'; END PROCESS reloj; pruebas : PROCESS BEGIN -- Asignacin de valores a las seales de entrada del componente a probar. -ED <= '1'; EI <= '0'; entrada <= "01101011"; -- CARGA , LDAS , LIAS c2 <= '1' , '1' AFTER 12ns,'0' AFTER 98ns; c1 <= '1' , '0' AFTER 12ns,'1' AFTER 98ns, '0' AFTER 200ns; WAIT; END PROCESS pruebas; END arquitectura;

20

PRCTICA OBLIGATORIA 4
Definicin de la entidad
La definicin de la entidad se realiza a partir de la figura mostrada en el guin de prctica:

ENTITY ascensor IS PORT( reloj : IN bit; subir : IN std_ulogic; bajar : IN std_ulogic; bajarPB : IN std_ulogic; parar : IN std_ulogic; Z : OUT std_ulogic); END ascensor;

La salida Z indicar el estado de las puertas, 1 abierto, 0 cerrado. Adems en el guin se fija la restriccin de no poder estar a valor activo dos botones a la vez. La entidad del codificador se define como:
ENTITY codificador IS PORT( y3: std_ulogic; y2: std_ulogic; y1: std_ulogic; y0: std_ulogic; H : std_ulogic; z1 : OUT std_ulogic; z0 : OUT std_ulogic; A : OUT std_ulogic); END codificador;

Modelo estructural
El modelo estructural se crea a partir del proceso descrito en el guin, realizacin del diagrama de flujos, derivacin de la tabla de estados, codificacin de los estados y las entradas, creacin de las tablas de transiciones y de excitacin. Finalmente obtenemos las ecuaciones de entrada a los biestables y mostramos el esquema del circuito final. Es necesario comentar que en lugar de especificar componentes AND y OR de dos puertas, realizamos una implementacin genrica mediante un nmero de entradas a genrico. Esta implementacin sigue cumpliendo un modelo estructural y aclara en gran medida la estructura del fichero. Se muestra a continuacin el codificador con este tipo de puertas, como se ve es necesario definir seales auxiliares para la interconexin:
aux1<=y3&y1; or1 : orN GENERIC MAP(2) PORT MAP(aux1,or1and1(1)); aux2<=y3&y2; or2 : orN GENERIC MAP(2) PORT MAP(aux2,or2and2(1)); aux3<=y3&y2&y1&y0; or3 : orN GENERIC MAP(4) PORT MAP(aux3,or3and3(1)); or1and1(0)<=H; or2and2(0)<=H; or3and3(0)<=H; and1 : andN GENERIC MAP(2) PORT MAP(or1and1,z0); and2 : andN GENERIC MAP(2) PORT MAP(or2and2,z1); and3 : andN GENERIC MAP(2) PORT MAP(or3and3,A);

21

Diagrama de flujos (autmata de Moore) Siguiendo el texto del guin, nuestro ascensor queda: Subir Subiendo Subir Bajar a PB Bajar Parar ParadoPB Bajar a PB Parado

Subir Parar

Bajar a PB Bajar Parar

Bajar a PB Subir Parar Bajando

Bajar Bajar

Tabla de Estados La tabla de estados que se obtiene del diagrama de flujo anterior es:
Tabla 1 Prximo Estado

Estado\Botn Parado PB Parado Subiendo Bajando

Subir SUBIENDO SUBIENDO SUBIENDO PARADO

Bajar PARADO PB BAJANDO PARADO BAJANDO

Bajar a PB PARADO PB PARADO PB PARADO PARADO

Parar PARADO PB PARADO PARADO PARADO

Puesto que es un autmata de Moore la salida solo depende del estado actual:
Tabla 2 Salida

Salida Z

Parado PB Abierto 1

Parado Abierto 1

Subiendo Cerrado 0

Bajando Cerrado 0

22

Codificacin de los estados y de las entradas Utilizamos dos bits para codificar cada estado y utilizando el codificador sin prioridad otros dos bits para codificar los botones. Estado Parado PB Parado Subiendo Bajando Codificacin 00 01 10 11 Botn Subir Bajar Bajar a PB Parar Valor 0 1 2 3 Codificacin 00 01 10 11

Tabla 3 Codificacin estados y entradas

Tabla de Transiciones y de excitacin Codificando los estados mediante sus valores en binario obtenemos la siguiente tabla. Q1Q0\X1X0 00 01 10 11
Tabla 4 de Transiciones

00 10 10 10 01

01 00 11 01 11

10 00 00 01 01

11 00 01 01 01

Como utilizamos biestables D la tabla de Transiciones coincide con la tabla de excitacin. Separamos las tablas en cada uno de los dos biestables para obtener luego las ecuaciones que nos fijan el valor del prximo estado Estado \Botn 00 01 11 10
Tabla 5 de Excitacin D1

00 1 1 0 1

01 0 1 1 0

11 0 0 0 0

10 0 0 0 0

Estado \Botn 00 01 11 10
Tabla 6 de Excitacin D0

00 0 0 1 0

01 0 1 1 1

11 0 1 1 1

10 0 0 1 1

Ecuaciones de entrada a los biestables Expresamos el prximo estado D, en funcin de la suma de mintrminos del estado actual Q y las entradas X. D1 = Q0 X1 X0 + Q1 X1 X0 + Q0 X1 X0 D0 = Q1 Q0 + Q0 X0 + Q1 X0 + Q1 X1

23

Esquema estructura del circuito secuencial resultante Utilizamos, como hemos nombrado, puertas AND y OR de un nmero genrico de entradas para simplificar el circuito, tambin se podra realizar componiendo puertas AND y OR de dos entradas para obtener puertas de un nmero mayor de entradas. El biestable D del circuito es el de las prcticas anteriores aadiendo a la salida, como es habitual, la seal negada. X0

X1

X0 X1 Q0

Q0

X0 X1 Q1

D1 D

Q1 Q1

X0 X1 Q0

Q1'

reloj

Circuito secuencial para D1

X1

X1 Q1

Q1

Q1 X0

D0 X0
X0 Q0

Q0 D Q0

reloj Q0
Q0 Q1

Circuito secuencial para D0

Q1

Circuito secuencial para Z

24

Pruebas del circuito

4 3 2 1

7 8

9 11 12 10 13 14

15 16 17 18

PB

P S P S P B B P B P B P PB

Se recorren todas las transiciones posibles entre estados del ascensor. Mostramos la traza sobre Q1 y Q0 necesaria para visualizar el estado actual interno del ascensor. Tenemos una transicin por pulso de reloj, hemos aadido un nmero que indica el orden de las transiciones que realizamos en la prueba, podemos ver como nos movemos por el diagrama de flujo donde tambin figura el orden de las transiciones. 5,Subir Subiendo 10 10,Bajar a PB 8,Bajar 6,Parar ParadoPB 00 3,Bajar a PB 2,Bajar 1,Parar 18,Bajar a PB Parado 01

4,Subir

7,9,Subir Parar

17,Bajar a PB 15,Subir 13,Parar

11,14,16,Bajar 12,Bajar Bajando 11

Como se ve las transiciones son las correctas en todos los casos

Cdigo VHDL
-- biestableD.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY biestableD IS PORT( reloj : IN bit; entrada: IN std_ulogic; salida : OUT std_ulogic:='0'; salidaN: OUT std_ulogic:='1');

25

END biestableD; -- biestableD_arq1.vhd ARCHITECTURE arq1 OF biestableD IS BEGIN PROCESS(reloj) -- sensible al reloj BEGIN IF (reloj='1') AND(reloj'EVENT) THEN salida<=entrada; salidaN<=NOT entrada; END IF; END PROCESS; END arq1;

-- inversor.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY inversor IS PORT( entrada: IN std_ulogic; salida : OUT std_ulogic); END inversor; -- inversor_arq1.vhd ARCHITECTURE arq1 OF inversor IS BEGIN salida <= NOT entrada; END arq1;

-- andN.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY andN IS GENERIC (n: integer :=2); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END andN; -- andN_arq1.vhd ARCHITECTURE arq1 OF andN IS BEGIN PROCESS VARIABLE y: std_ulogic; BEGIN y:='1'; FOR i IN n-1 DOWNTO 0 LOOP y:=entrada(i) and y; END LOOP; salida <= y; WAIT ON entrada; END PROCESS; END arq1; -- orN.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY orN IS GENERIC (n: integer :=2); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END orN; -- orN_arq1.vhd ARCHITECTURE arq1 OF orN IS BEGIN PROCESS VARIABLE y: std_ulogic;

26

BEGIN y:='0'; FOR i IN n-1 DOWNTO 0 LOOP y:=entrada(i) or y; END LOOP; salida <= y; WAIT ON entrada; END PROCESS; END arq1; -- codificador.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY codificador IS PORT( y3: std_ulogic; y2: std_ulogic; y1: std_ulogic; y0: std_ulogic; H : std_ulogic; z1 : OUT std_ulogic; z0 : OUT std_ulogic; A : OUT std_ulogic); END codificador; -- codificador_arq1.vhd ARCHITECTURE arq1 OF codificador IS -- Declaracin del componente a probar. COMPONENT orN GENERIC(n: integer); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END COMPONENT; COMPONENT andN GENERIC(n: integer); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END COMPONENT; -- SIGNALS para interconexin SIGNAL or1and1,or2and2,or3and3 : std_ulogic_vector(1 DOWNTO 0); SIGNAL aux1 : std_ulogic_vector(1 DOWNTO 0); SIGNAL aux2 : std_ulogic_vector(1 DOWNTO 0); SIGNAL aux3 : std_ulogic_vector(3 DOWNTO 0); BEGIN aux1<=y3&y1; or1 : orN GENERIC MAP(2) PORT MAP(aux1,or1and1(1)); aux2<=y3&y2; or2 : orN GENERIC MAP(2) PORT MAP(aux2,or2and2(1)); aux3<=y3&y2&y1&y0; or3 : orN GENERIC MAP(4) PORT MAP(aux3,or3and3(1)); or1and1(0)<=H; or2and2(0)<=H; or3and3(0)<=H; and1 : andN GENERIC MAP(2) PORT MAP(or1and1,z0); and2 : andN GENERIC MAP(2) PORT MAP(or2and2,z1); and3 : andN GENERIC MAP(2) PORT MAP(or3and3,A); END arq1; -- ascensor.vhd LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY ascensor IS PORT( reloj : IN bit; subir : IN std_ulogic; bajar : IN std_ulogic; bajarPB : IN std_ulogic; parar : IN std_ulogic; Z : OUT std_ulogic); END ascensor; -- ascensor_arq1.vhd

27

ARCHITECTURE arq1 OF ascensor IS -- Declaracin de componentes. COMPONENT biestableD PORT( reloj : IN bit; entrada: IN std_ulogic; salida : OUT std_ulogic; salidaN: OUT std_ulogic); END COMPONENT; COMPONENT inversor PORT( entrada: IN std_ulogic; salida : OUT std_ulogic); END COMPONENT; COMPONENT orN GENERIC(n: integer:=2); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END COMPONENT; COMPONENT andN GENERIC(n: integer:=2); PORT( entrada: IN std_ulogic_vector(n-1 DOWNTO 0); salida : OUT std_ulogic); END COMPONENT; COMPONENT codificador PORT( y3: std_ulogic; y2: std_ulogic; y1: std_ulogic; y0: std_ulogic; H : std_ulogic; z1 : OUT std_ulogic; z0 : OUT std_ulogic; A : OUT std_ulogic); END COMPONENT; -- SEALES GENERALES SIGNAL A,H,x1,x0,x1n,x0n : std_ulogic; SIGNAL Q1,Q0,Q1n,Q0n : std_ulogic; SIGNAL D1,D0 : std_ulogic; -- SEALES para obtener D1 SIGNAL D1aux1 : std_ulogic_vector(2 DOWNTO 0); SIGNAL D1aux2 : std_ulogic_vector(2 DOWNTO 0); SIGNAL D1aux3 : std_ulogic_vector(2 DOWNTO 0); SIGNAL D1aux4 : std_ulogic_vector(2 DOWNTO 0); SIGNAL D1and1,D1and2,D1and3 : std_ulogic; -- SEALES para obtener D0 SIGNAL D0aux1 : std_ulogic_vector(1 DOWNTO 0); SIGNAL D0aux2 : std_ulogic_vector(1 DOWNTO 0); SIGNAL D0aux3 : std_ulogic_vector(1 DOWNTO 0); SIGNAL D0aux4 : std_ulogic_vector(1 DOWNTO 0); SIGNAL D0aux5 : std_ulogic_vector(3 DOWNTO 0); SIGNAL D0and1,D0and2,D0and3,D0and4 : std_ulogic; BEGIN deco : codificador PORT MAP(parar,bajarPB,bajar,subir,H,x1,x0,A); inv1 : inversor PORT MAP(x0,x0n); inv2 : inversor PORT MAP(x1,x1n); H<='1'; -- generacin de D1 D1aux1<=x0n&x1n&Q0n; and1 : andN GENERIC MAP(3) PORT MAP(D1aux1,D1and1); D1aux2<=Q1n&x1n&x0n; and2 : andN GENERIC MAP(3) PORT MAP(D1aux2,D1and2); D1aux3<=Q0&x1n&x0; and3 : andN GENERIC MAP(3) PORT MAP(D1aux3,D1and3); D1aux4<=D1and1&D1and2&D1and3; or1 : orN GENERIC MAP(3) PORT MAP(D1aux4,D1); bi1 : biestableD PORT MAP(reloj,D1,Q1,Q1n); -- generacin de D0 D0aux1<=Q1&Q0; and4 : andN PORT MAP(D0aux1,D0and1);

28

D0aux2<=Q0&x0; and5 : andN PORT MAP(D0aux2,D0and2); D0aux3<=Q1&x0; and6 : andN PORT MAP(D0aux3,D0and3); D0aux4<=Q1&x1; and7 : andN PORT MAP(D0aux4,D0and4); D0aux5<=D0and1&D0and2&D0and3&D0and4; or2 : orN GENERIC MAP(4) PORT MAP(D0aux5,D0); bi2 : biestableD PORT MAP(reloj,D0,Q0,Q0n); -- salida del ascensor Z<=Q1n; END arq1;

-- test_ascensor.vhd USE WORK.ALL; LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.all; ENTITY test_ascensor IS END test_ascensor; ARCHITECTURE arquitectura OF test_ascensor IS -- Declaracin del componente a probar. COMPONENT ascensor PORT( reloj : IN bit; subir : IN std_ulogic; bajar : IN std_ulogic; bajarPB : IN std_ulogic; parar : IN std_ulogic; Z : OUT std_ulogic); END COMPONENT; CONSTANT duracion_ciclo: TIME:=5ns; SIGNAL CLK_s:BIT:='0'; -- Declaracin de seales de entrada y salida del componente a probar. SIGNAL subir :std_ulogic; SIGNAL bajar :std_ulogic; SIGNAL bajarPB :std_ulogic; SIGNAL parar :std_ulogic; SIGNAL Z : std_ulogic; BEGIN asc1 : ascensor PORT MAP(CLK_s,subir,bajar,bajarPB,parar,Z); reloj : PROCESS BEGIN WAIT FOR duracion_ciclo; CLK_s <= '1'; WAIT FOR duracion_ciclo; CLK_s <= '0'; END PROCESS reloj; pruebas : PROCESS BEGIN -- Asignacin de valores a las seales de entrada del componente a probar. subir <= '0', '1' AFTER 32 ns, '0' AFTER 52 ns,'1' AFTER 62ns,'0' AFTER 72ns, '1' AFTER 82ns, '0' AFTER 92ns,'1' AFTER 142ns, '0' AFTER 152ns; bajar <= '0', '1' AFTER 22 ns, '0' AFTER 32 ns,'1' AFTER 72ns,'0' AFTER 82ns, '1' AFTER 102ns, '0' AFTER 122ns,'1' AFTER 132ns, '0' AFTER 142ns, '1' AFTER 152ns, '0' AFTER 162ns; bajarPB <= '0', '1' AFTER 12 ns, '0' AFTER 22 ns,'1' AFTER 92ns,'0' AFTER 102 ns, '1' AFTER 162ns; parar <= '0', '1' AFTER 2 ns, '0' AFTER 12 ns,'1' AFTER 52ns,'0' AFTER 62ns, '1' AFTER 122ns, '0' AFTER 132ns; WAIT; END PROCESS pruebas; END arquitectura;

29

CONCLUSIONES OPINIONES Y MEJORAS

Personalmente, la realizacin de las prcticas es la mejor forma para aprender acerca del lenguaje VHDL. Por otro lado la realizacin de esta memoria me ha sido un poco difcil, por que no saba exactamente que comentar a cerca de cada prctica obligatoria, adems como se ha visto he incluido las actividades voluntarias. Tal vez un guin con preguntas especficas a responder en la memoria hubiera sido ms sencillo. El mtodo de entrega, a travs de correo, y no realizar sesiones presenciales obligatorias, facilita en gran medida la elaboracin de estas prcticas, ya que utilizar el lenguaje VHDL dentro de un simulador nos permite realizar ejemplos y corregir los fallos que se cometen a nuestro propio ritmo. Aunque el simulador utilizado es muy sencillo de manejar en algunas ocasiones, sobretodo en lo referente a errores, es un poco difcil entender la informacin que nos facilita. Como mejora eliminara alguna prctica obligatoria un poco repititiva, como la 3 y la cambiara por un tipo de la misma dificultad pero de otro tema de VHDL. Tambin aadira ms prcticas de carcter voluntario y sera interesante colocar en el servidor un modelo resuelto de las prcticas de otros aos. Las prcticas me han parecido adecuadas, ya que presentan un grado de dificultad creciente fcil de seguir. El ascensor descrito en la prctica 4, es confuso y poco realista. Hubiera sido mejor utilizar un sistema ms sencillo, pero realizar este modelado de una forma ms fiel a la realidad.

30