Codigo VHDL para Ascensor

11.
2 Ejemplos para simulacion y sntesis 93

motor<='0';
presente<=encendido;
END IF;
WHEN encendido =>
motor<='1';
presente<=apagado;
END CASE;
END IF;
END PROCESS;
END para_sintesis;
Si repasamos la descripcion anterior y la intentamos simular a mano con todo lo que

sabemos, veremos que cuando el estado es apagado motor el vale uno, y viceversa, es
decir, lo contrario de lo que parece. Si esto nos causa mucha confusion, podemos dividir
el problema en dos procesos, uno que interpreta el estado y otro el cambio de estado:
maquina: salida:
PROCESS(boton) PROCESS(presente)
BEGIN BEGIN
IF boton='1' THEN CASE presente IS
CASE presente IS WHEN apagado=>
WHEN apagado=> motor<='0';
presente<=encendido; WHEN encendido=>
WHEN encendido=> motor<='1';
presente<=apagado; END CASE;
END CASE; END PROCESS salida;
END IF;
END PROCESS maquina;
Esta descripcion es mas interesante ya que en este caso esta mas claro lo que quere-
mos decir y tanto la simulacion como la sntesis coinciden. Quiza alguien podra pensar
que una posible solucion sera poner presente en la lista sensible, pero esto, aunque la
simulacion estara bien, sintetizara otro circuito diferente. O sea, que es aconsejable
seguir un unico modelo para la maquina de estados, que funcione bien para sntesis, y
no salirse de ah.
11.2.2 Los semaforos

Ejemplo 11.2 Realizar el circuito de control de unos semaforos que controlan un cruce
entre un camino rural y una carretera. En principio, el semaforo del camino rural
siempre esta en rojo y el de la carretera en verde. Una celula en el camino rural
detecta la presencia de un coche, momento en el cual el semaforo de la carretera pasa
de verde a rojo pasando por el ambar, al tiempo que el semaforo del camino se pone en
verde. El semaforo del camino permanece en verde unos 10 segundos, momento en el
cual empieza la secuencia de puesta a rojo, al tiempo que el semaforo de la carretera
empieza la secuencia de cambio hacia el verde. El semaforo del camino no debe ponerse
en verde otra vez hasta transcurridos 30 segundos por lo menos. El circuito tiene una
entrada de reloj de 1 segundo de periodo y las se~nales de entrada y salida sucientes
para el control del semaforo.
Como se da una se~nal de reloj como entrada, es interesante realizar la maquina de

estados de manera que sea sncrona con este reloj, de esta manera se evitan proble-
mas de metaestabilidad con las entradas, ademas de que las herramientas de sntesis
interpretaran mejor que el circuito es una maquina de estados y el resultado sera mas
Ingeniera Informatica Universidad de Valencia
94 Utilizacion del lenguaje VHDL
optimo. Junto con la maquina de estados habra otros procesos que controlen los tiempos
de espera mediante contadores.
La entrada al sistema sera una se~nal de reset asncrona, que es lo habitual, y las
fotocelulas del camino, que indicaran un '1' cuando detecten un coche. Las salidas
seran un total de 6, 3 para cada semaforo, indicando cada una de estas tres el color
rojo, ambar y verde. Con estas consideraciones la entidad y arquitectura quedaran:
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY semaforo IS
PORT (sensor,reset,clk: IN std_logic;
semcamin,semcarr: OUT std_logic_vector(0 TO 2));
END semaforo;
ARCHITECTURE descripcion OF semaforo IS

TYPE estado IS (inicial,carramarillo,caminverde,caminamarillo,espera);
CONSTANT verde: std_logic_vector(0 TO 2):="001";
CONSTANT amarillo: std_logic_vector(0 TO 2):="010";
CONSTANT rojo: std_logic_vector(0 TO 2):="100";
SIGNAL presente: estado:=inicial;
SIGNAL rescont: boolean:=false; -- Pone a cero la cuenta
SIGNAL fin_largo,fin_corto: boolean; -- Indica fin de cuenta
SIGNAL cuenta: integer RANGE 0 TO 63;
BEGIN
-- Lo primero es definirse la maquina de estados:

maquina:
PROCESS(clk,reset)
BEGIN
IF reset='1' THEN
presente<=inicial;
ELSIF clk='1' AND clk'EVENT THEN
CASE presente IS
WHEN inicial=>
IF sensor='1' THEN
presente<=carramarillo;
END IF;
WHEN carramarillo=>
presente<=caminverde;
WHEN caminverde=>
IF fin_corto THEN
presente<=caminamarillo;
END IF;
WHEN caminamarillo=>
presente<=espera;
WHEN espera=>
IF fin_largo THEN
presente<=inicial;
END IF;
END CASE;
END IF;
END PROCESS maquina;
salida:
PROCESS(presente)
BEGIN
CASE presente IS
WHEN inicial=>
semcarr<=verde;
semcamin<=rojo;
rescont<=true;
WHEN carramarillo=>
semcarr<=amarillo;
semcamin<=rojo;

11.2 Ejemplos para simulacion y sntesis 95
rescont<=true;
WHEN caminverde=>
semcarr<=rojo;
semcamin<=verde;
rescont<=false;
WHEN caminamarillo=>
semcarr<=rojo;
semcamin<=amarillo;
rescont<=true;
WHEN espera=>
semcarr<=verde;
semcamin<=rojo;
rescont<=false;
END CASE;
END PROCESS salida;
-- El siguiente proceso define el contador:

contador:
PROCESS(clk)
BEGIN
IF clk='1' THEN
IF rescont THEN cuenta<=0;
ELSE cuenta<=cuenta+1;
END IF;
END IF;
END PROCESS contador;
-- Queda la deteccion de los tiempos largos y cortos:

fin_largo<=true WHEN cuenta=29 ELSE false;
fin_corto<=true WHEN cuenta=9 ELSE false;
END descripcion;
11.2.3 El ascensor
Ejemplo 11.3 Describir el controlador de un ascensor unico en una vivienda de 4
pisos. Las entradas al circuito seran, por un lado, el piso al que el usuario desea
ir mediante 4 botones, y el piso en el que se encuentra el ascensor en un momento
dado. Por otro, habra una celula que detecte la presencia de algun obstaculo en la
puerta, si hay un obstaculo la puerta no debe cerrarse. La salida sera por un lado el
motor (mediante dos bits), y la puerta (un bit). El funcionamiento es bien simple: el
ascensor debe ir al piso indicado por los botones, cuando llegue abrira las puertas que
permaneceran as hasta que se reciba otra llamada. El ascensor no tiene memoria por
lo que si se pulsan los botones mientras el ascensor se mueve, no hara caso.
ENTITY ascensor IS
PORT(boton: IN bit_vector(0 TO 3);
piso: IN bit_vector(1 DOWNTO 0);
clk,reset,celula: IN bit;
motor: OUT bit_vector(0 TO 1);
puerta: OUT bit);
END ascensor;
ARCHITECTURE mover OF ascensor IS

TYPE estado IS (inicial,cerrar,voy);
SUBTYPE vector IS bit_vector(2 DOWNTO 0);
SIGNAL presente: estado:=inicial;
SIGNAL bot: bit_vector(2 DOWNTO 0);
FUNCTION codifica(pulso: bit_vector(0 TO 3)) RETURN vector IS

BEGIN
CASE pulso IS

96 Utilizacion del lenguaje VHDL
WHEN "0001"=>RETURN "000";
WHEN "0010"=>RETURN "001";
WHEN "0100"=>RETURN "010";
WHEN "1000"=>RETURN "011";
WHEN OTHERS=>RETURN "100";
END CASE;
END codifica;
BEGIN
fsm:
PROCESS(reset,clk)
BEGIN
IF reset='1' THEN presente<=inicial;
ELSIF clk='1' AND clk'EVENT THEN
CASE presente IS
WHEN inicial=>
IF bot/="100" THEN presente<=cerrar;
END IF;
WHEN cerrar=>
IF celula='0' THEN presente<=voy; -- Sin obtaculos
END IF;
WHEN voy=>
IF bot(1 DOWNTO 0)=piso THEN presente<=inicial;
END IF;
END CASE;
END IF;
END PROCESS fsm;
salida:
PROCESS(presente,boton)
BEGIN
CASE presente IS
WHEN inicial=>
motor<="00"; -- Parado
puerta<='1'; -- Abierta
bot<=codifica(boton);
WHEN cerrar=>
motor<="00";
puerta<='1';
WHEN voy=>
puerta<='0'; -- Cerrada
IF bot(2 DOWNTO 0)>piso THEN
motor<="10"; -- Subir
ELSE motor<="01"; -- Bajar
END IF;
END CASE;
END PROCESS salida;
END mover;
El funcionamiento no es muy complejo. Si nadie pulsa nada se mantiene en el estado

inicial, si alguien pulsa entonces se cierran las puertas y el motor se pone en marcha en
direccion al piso que se llamo. Cuando llega se abren las puertas y se queda a esperar
una nueva llamada.
La funcion codifica se ha puesto para mostrar la inclusion de una funcion en una
descripcion. Realmente el programa funciona exactamente igual de bien, con peque~nas
modicaciones, si se utiliza bot como una se~nal de 4 bits. Esta se~nal sigue siendo
necesaria puesto que se encarga de capturar la pulsacion del boton.
El ejemplo del ascensor que se acaba de mostrar no es demasiado realista, por un
lado las puertas se cierran de golpe, y por otro, la parada y puesta en marcha del
ascensor es tambien muy brusca. De todas formas pone de maniesto la capacidad de
11.2 Ejemplos para simulacion y sntesis 97
funcionamiento del VHDL para la descripcion de hardware. Como ejercicio adicional se
puede hacer el ejemplo anterior pero a~nadiendole caractersticas mas realistas como la
deteccion de obstaculos durante el cierre de puertas, o la posibilidad de gestionar mas
de un boton pulsado.
11.2.4 La memoria ROM

Ejemplo 11.4 Realizar el modelo de simulacion de una memoria ROM simple. La
ROM tiene una entrada de seleccion activa a nivel bajo, de manera que cuando esta ac-
tiva, la salida es el contenido de la posicion indicada por la direccion de entrada, sino
esta activa, la salida es alta impedancia. El tiempo que pasa entre que cambia la selec-
cion y la salida es de 60 ns. El tiempo que pasa entre que la direccion cambia y cambia
la salida es de 100 ns. En el caso de cambio en la direccion, la salida mantiene su valor
anterior durante 10 ns y luego pasa a desconocido.
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY rom IS
PORT( cen: IN std_logic;
direcc: IN std_logic_vector(1 DOWNTO 0);
dato: OUT std_logic_vector(7 DOWNTO 0));
END rom;
ARCHITECTURE modelo OF rom IS

SIGNAL salida: std_logic_vector(7 DOWNTO 0);
SIGNAL cenr: std_logic:
BEGIN
PROCESS(direcc)
BEGIN
salida<="XXXXXXXX" AFTER 10 ns;
CASE direcc IS
WHEN "00"=>salida<=TRANSPORT "00000000" AFTER 100 ns;
WHEN OTHERS=> NULL;
END CASE;
END PROCESS;
dato<=salida WHEN cenr='0' ELSE

(OTHERS 'Z') WHEN cenr='1' ELSE
(OTHERS 'X');
cenr<=cen AFTER 60 ns;
END modelo;
El modelo no requiere demasiadas explicaciones. Quiza sea interesante resaltar

que para el caso del retraso de 100 ns de la salida se ha empleado el retraso de tipo
transportado en vez del inercial, la razon es que este evento se asigna al mismo tiempo
que de 10 ns, de manera que si no fuese transportado quitara el otro evento de la lista
de eventos y no se ejecutara nunca.
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;
codifica_boton;
ARCHITECTURE
ARCHITECTURE arquitectura_co
arquitectura_cod_boton
d_boton OF codifica_boton
codifica_boton IS
BEGIN
PROCESS (piso_donde_va)
BEGIN
CASE (piso_donde_va) IS
WHEN "001"=> codigo_piso <="00";
WHEN OTHERS => codigo_piso <="11";
END CASE;
END PROCESS;
END arquitectura_cod_boton;
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;
codifica_boton_test;
ARCHITECTURE
ARCHITECTURE arquitectura_boton
arquitectura_boton_test
_test OF codifica_boton_test
codifica_boton_test IS
-- Declaración del componente
COMPONENT codifica_boton IS
PORT
piso_donde_va
piso_donde _va : IN STD_LOGIC_VECTOR (2 DOWNTO 0); -- selección de piso
codigo_piso
codigo_pi so : 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
piso_donde _va : STD_LOGIC_VECTOR (2 DOWNTO 0); -- boton que se activa
SIGNAL codigo_piso
codigo_p iso : 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
"000" AFTER 4 * periodo, -- sin marcar piso
"111" AFTER 5 * periodo, -- se aprietan tres botones a la vez

"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.
Sergio Carrégalo Díaz Sistemas Electrónicos y Automáticos
Cristina Amián Sánchez Practica 4
Se desea automatizar el funcionamiento de un montacargas para trasladar

materiales entre las dos plantas de una nave industrial, como se muestra en la
siguiente figura.
Para ello se han instalado los siguientes elementos:

- Un interruptor S que permite seleccionar el sentido del desplazamiento (S=0:
bajar; S=1: subir).
- Dos finales de carrera PA y PB que adoptan niveles altos cuando la cabina llega
a la planta alta y a la planta baja, respectivamente.
- Un sistema de tracción dotado de dos señales de control (A: ascender y D:
descender).
El funcionamiento debe ser el siguiente:

- Cuando se coloque el interruptor S en la posición ‘1’, la cabina ascenderá hasta
que llegue a la planta alta o se cambie de posición dicho interruptor.
- Cuando se coloque el interruptor S en la posición ‘0’, la cabina descenderá hasta
que llegue a la planta baja o se cambie de posición dicho interruptor.
1
El diagrama de estados que asocia las señales de entrada con el

funcionamiento del ascensor es el siguiente.
PB/S PA/S
Q3 Q0
PB S
PA
S
Q2 Q1
S
PB/S PA/S
2
Sabiendo que:
Q0: Ascensor subiendo

Q1: Ascensor en planta alta
Q2: Ascensor bajando
Q3: Ascensor en planta baja
PA: sensor planta alta activo

PB: sensor planta baja activo
S: llamada a subir
S: llamada a bajar
Las ecuaciones de estado tras analizar el diagrama de estados son:
Q0 = pa·s + q2·s +q3·s = s (pa +q2 +q3)

Q1 = q0·pa + pa·s = pa (q0 + s)
Q2 = q1·s + pb·s + q0·s = s (q1 + pb + q0)
Q3 = q2pb + s·pb = pb (q2 + s)
El diagrama lógico sera:
3
Ahora procedemos a implementar los ficheros de VHDL Module. Se creará uno

para el flip-flop D, y otro para el diagrama de control (p4). El código fuente es pues:
--Flip-flop D
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity FF_D is
Port ( PRESET : in STD_LOGIC;
CLEAR : in STD_LOGIC;
CLK : in STD_LOGIC;
D : in STD_LOGIC;
Q : out STD_LOGIC);
end FF_D;
architecture A_FF_D of FF_D is
begin
process (CLEAR, CLK)
begin
if CLEAR = '1' and PRESET = '0' then Q <='0';
elsif CLEAR = '0' and PRESET = '1' then Q <= '1';
elsif CLK'event and CLK = '1' then Q <= D;
end if;
end process;
4
-- Circuito de control (p4)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity P4 is
Port ( RESET : in STD_LOGIC;
CLK : in STD_LOGIC;
S : in STD_LOGIC;
PA : in STD_LOGIC;
PB : in STD_LOGIC;
Q0 : out STD_LOGIC;
Q1 : out STD_LOGIC;
Q2 : out STD_LOGIC;
Q3 : out STD_LOGIC;
A : out STD_LOGIC;
D : out STD_LOGIC);
end P4;
architecture A_P4 of P4 is
signal D0,D1,D2,D3:STD_LOGIC;
signal Q0_I:STD_LOGIC:= '1';
signal Q1_I,Q2_I,Q3_I:STD_LOGIC;
signal A_I,D_I:STD_LOGIC;
component FF_D is
Port ( PRESET : in STD_LOGIC;
CLEAR : in STD_LOGIC;
CLK : in STD_LOGIC;
D : in STD_LOGIC;
Q : out STD_LOGIC);
end component;
5
begin
FF1:FF_D port map(RESET, '0', CLK, D0, Q0_I);
FF2:FF_D port map('0', RESET, CLK, D1, Q1_I);
D0<=(S AND NOT PA) OR (Q2_I AND S) OR (Q3_I AND S);
D1<=(Q0_I AND PA) OR (PA AND S);
D2<=(Q0_I AND NOT S) OR (NOT PB AND NOT S) OR (Q1_I AND NOT S);
D3<=(Q2_I AND PB) OR (NOT S AND PB);
Q0<=Q0_I;
Q1<=Q1_I;
Q2<=Q2_I;
Q3<=Q3_I;
D<=Q2_I;
A<=Q0_I;
A_I<=Q0_I;
D_I<=Q2_I;
end A_P4;
Se genera ahora el fichero TEST con los estímulos, para obtener la simulación en
el tiempo del circuito. El código fuente es el siguiente:
LIBRARY ieee;
SE ieee.std_logic_1164.ALL;
ENTITY T_FF_D IS
END T_FF_D;
ARCHITECTURE behavior OF T_FF_D IS
6
COMPONENT P4
PORT(
RESET : IN std_logic;
CLK : IN std_logic;
S : IN std_logic;
PA : IN std_logic;
PB : IN std_logic;
Q0 : OUT std_logic;
Q1 : OUT std_logic;
Q2 : OUT std_logic;
Q3 : OUT std_logic;
A : OUT std_logic;
D : OUT std_logic
);
END COMPONENT;
--Inputs
signal RESET : std_logic := '0';
signal CLK : std_logic := '0';
signal S : std_logic := '0';
signal PA : std_logic := '0';
signal PB : std_logic := '0';
--Outputs
signal Q0 : std_logic;
signal A : std_logic;
signal D : std_logic;
-- Clock period definitions
constant CLK_period : time := 100 ns;
7
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: P4 PORT MAP (
RESET => RESET,
CLK => CLK,
S => S,
PA => PA,
PB => PB,
Q0 => Q0,
Q1 => Q1,
Q2 => Q2,
Q3 => Q3,
A => A,
D => D
);
-- Clock process definitions
CLK_process :process
begin
CLK <= '0';
wait for CLK_period/2;
CLK <= '1';
wait for CLK_period/2;
end process;
RESET <= '1', '0' after 100 ns;
S <= '0', '1' after 200 ns, '0' after 600 ns, '1' after 800 ns, '0' after 900 ns;
PA <= '0', '1' after 400 ns, '0' after 700 ns;
PB <= '1', '0' after 300 ns, '1' after 1000 ns;
END;
8
Simulándolo, obtenemos el siguiente diagrama de estímulos:
Analizamos los resultados obtenidos:
Al inicio del cronograma tenemos que la única señal activa al inicio es PB, lo que
no indica que el ascensor se encuentra en la planta baja. A los 200ns se activa el
pulsador de llamada, lo que no indica que desde la planta alta se ha requerido la
subida del ascensor. Por tanto, se pasa al estado Q0, para indicar que el ascensor
esta subiendo. Cuando se el sensor de planta alta (PA) se activa, se pasa al
estado Q1, indicándonos que el ascensor ya esta arriba, y el estado Q0 pasa a
nivel lógico bajo.
A Los 600ns se desactiva el pulsador de llamada, lo que quiere decir que se
requiere al ascensor en la planta baja. En el siguiente flanco de bajada del reloj, se
desactiva PA, para indicarnos que el ascensor ya no esta en la planta baja, y se
pasa al estado Q2, es decir, ascensor bajando.
En 833 nos, se vuelve a llamar al ascensor a la subida, por lo que se pasa al
estado Q0, y se vuelve a repetir el proceso primero.
Seguidamente vamos a pasar a conectar nuestro diseño a la placa a BASY, para

simularla con un micro, y ver su funcionamiento real. En primera lugar se generará
el fichero que conecte las variables de entrada y salida, según la siguiente placa:
9
Las salidas del circuito del ascensor quedan por tanto relacionadas con la entrada
de la placa de la siguiente manera:
A continuación se muestra la conexión a la placa
10

Codigo VHDL para Ascensor

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Codigo VHDL para Ascensor

Загружено:

Авторское право:

Доступные форматы

11.

2 Ejemplos para simulacion y sntesis 93

Si repasamos la descripcion anterior y la intentamos simular a mano con todo lo que

11.2.2 Los semaforos

Como se da una se~nal de reloj como entrada, es interesante realizar la maquina de

ARCHITECTURE descripcion OF semaforo IS

-- Lo primero es definirse la maquina de estados:

Ingeniera Informatica Universidad de Valencia

-- El siguiente proceso define el contador:

-- Queda la deteccion de los tiempos largos y cortos:

ARCHITECTURE mover OF ascensor IS

FUNCTION codifica(pulso: bit_vector(0 TO 3)) RETURN vector IS

Ingeniera Informatica Universidad de Valencia

El funcionamiento no es muy complejo. Si nadie pulsa nada se mantiene en el estado

11.2.4 La memoria ROM

ARCHITECTURE modelo OF rom IS

dato<=salida WHEN cenr='0' ELSE

El modelo no requiere demasiadas explicaciones. Quiza sea interesante resaltar

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

codigo_piso:OUT std_logic_vector (1 DOWNTO 0));

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

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

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

WHEN OTHERS => codigo_piso <="11";

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

CONSTANT periodo : TIME := 20 ns;

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

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

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

ARCHITECTURE flujo_asin OF biestable_D_con_clr IS

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

Este es el campo de trabajo

Se desea automatizar el funcionamiento de un montacargas para trasladar

Para ello se han instalado los siguientes elementos:

El funcionamiento debe ser el siguiente:

El diagrama de estados que asocia las señales de entrada con el

Q0: Ascensor subiendo

PA: sensor planta alta activo

Las ecuaciones de estado tras analizar el diagrama de estados son:

Q0 = pa·s + q2·s +q3·s = s (pa +q2 +q3)

El diagrama lógico sera:

Ahora procedemos a implementar los ficheros de VHDL Module. Se creará uno

Port ( PRESET : in STD_LOGIC;

architecture A_FF_D of FF_D is

process (CLEAR, CLK)

if CLEAR = '1' and PRESET = '0' then Q <='0';

elsif CLEAR = '0' and PRESET = '1' then Q <= '1';

elsif CLK'event and CLK = '1' then Q <= D;

-- Circuito de control (p4)

Port ( RESET : in STD_LOGIC;

signal Q0_I:STD_LOGIC:= '1';

2 Ejemplos para simulacion y sntesis 93

Si repasamos la descripcion anterior y la intentamos simular a mano con todo lo que

11.2.2 Los semaforos

Como se da una se~nal de reloj como entrada, es interesante realizar la maquina de

Ingeniera Informatica Universidad de Valencia

Ingeniera Informatica Universidad de Valencia

El modelo no requiere demasiadas explicaciones. Quiza sea interesante resaltar