Universidad Nacional Autónoma de México

Facultad de ingeniería
Arquitectura de computadoras

Practica 2 “Introducción al lenguaje VHDL”

Grupo: 04

Nombres:
Gonzales Gonzales Dora Isabel
Linares Fuentes Alan
Monzalbo Núñez Jorge
Pozos Pozos Noe
Objetivo:
Familiarizar al alumno en el conocimiento de los algoritmos de las máquinas de
estados utilizando el lenguaje VHDL.

Introducción:
Una máquina de estados es una estructura de programa que nos sirve para
determinar el comportamiento de algo en base al estado en el que se
encuentre. Para cada estado por tanto se tendrá un comportamiento.
Siempre que pensemos utilizar una máquina de estados es muy recomendable
dibujar primero un diagrama de estados.
Un diagrama de estados se compone de 2 elementos principales: Estados y
Transiciones.
 Estados
Un estado representa el comportamiento de un elemento que hace algo
durante cierto tiempo.
Representaremos los estados con rectángulos. Y si queremos
especificar lo que se hace mientras nos encontremos dentro de ese
estado, lo haremos entre llaves.
 Transición
Una transición es el paso de un estado de origen a otro de destino.
Tiene siempre asociada una condición y puede requerir la ejecución de
alguna acción.
Representaremos las transiciones con una flecha a la que añadiremos
una línea horizontal. La flecha va del estado de origen al estado destino
de la transición. Encima de esa línea colocaremos la condición que
desencadena la transición. Debajo de la línea colocaremos las acciones
que queremos que se ejecuten en cada transición.
Las acciones que asociamos a una transición se ejecutan solo una vez
al principio del estado de destino. Las acciones que asociamos a un
estado se ejecutan siempre que permanezcamos en ese estado.
Desarrollo:
Como primer paso observamos la máquina de estados que vamos a programar
para posteriormente cargarlo en la FPGA y ver su funcionamiento, así mismo
como implementarlo en un carrito y ver los giros que debe de realizar
dependiendo en el estado que se encuentre.
Ya con el código creamos un nuevo proyecto en Quartus y compilamos el
código siguiente
library IEEE; giro_izq <= '1';
use IEEE.STD_LOGIC_1164.ALL; giro_der <= '0';
use IEEE.STD_LOGIC_ARITH.ALL; esiguiente<= s0;
use IEEE.STD_LOGIC_UNSIGNED.ALL; when s3 =>
entity carta_asm_2 is adelante <= '0';
Port ( RELOJ : in STD_LOGIC; atras <= '1';
RESET : in STD_LOGIC; giro_izq <= '0';
S : in std_logic_vector (1 downto 0); --DONDE EL BIT giro_der <= '0';
MAS SIGNIFICATIVO esiguiente<= s4;
ES SI Y EL MENOS EL SD when s4 =>
atras : out STD_LOGIC; adelante <= '0';
adelante : out STD_LOGIC; atras <= '0';
giro_der : out STD_LOGIC; giro_izq <= '0';
giro_izq : out STD_LOGIC; giro_der <= '1';
out_epresente :out std_logic_vector (3 downto 0)); esiguiente<= s0;
end carta_asm_2; when s5 =>
architecture Behavioral of carta_asm_2 is adelante <= '0';
signal esiguiente : std_logic_vector (3 downto 0) := atras <= '1';
B"0000"; giro_izq <= '0';
constant s0 : std_logic_vector(3 downto 0) := X"0"; giro_der <= '0';
constant s1 : std_logic_vector(3 downto 0) := X"1"; esiguiente<= s6;when s6 =>
constant s2 : std_logic_vector(3 downto 0) := X"2"; adelante <= '0';
constant s3 : std_logic_vector(3 downto 0) := X"3"; atras <= '0';
constant s4 : std_logic_vector(3 downto 0) := X"4"; giro_izq <= '1';
constant s5 : std_logic_vector(3 downto 0) := X"5"; giro_der <= '0';
constant s6 : std_logic_vector(3 downto 0) := X"6"; esiguiente<= s7;
constant s7 : std_logic_vector(3 downto 0) := X"7"; when s7 =>
constant s8 : std_logic_vector(3 downto 0) := X"8"; adelante <= '0';
constant s9 : std_logic_vector(3 downto 0) := X"9"; atras <= '0';
constant s10 : std_logic_vector(3 downto 0) := X"A"; giro_izq <= '1';
constant s11 : std_logic_vector(3 downto 0) := X"B"; giro_der <= '0';
begin esiguiente<= s8;
process (RELOJ,reset,esiguiente, S) when s8 =>
begin adelante <= '1';
if reset='0' then esiguiente <=s0; atras <= '0';
elsif rising_edge (RELOJ) then giro_izq <= '0';
case esiguiente is giro_der <= '0';
when s0 =>atras <= '0'; esiguiente<= s9;
giro_izq <= '0'; when s9 =>
giro_der <= '0'; adelante <= '1';
if S =X"0" then atras <= '0';
adelante <= '1'; giro_izq <= '0';
esiguiente<= s0; giro_der <= '0';
elsif S =X"1" then esiguiente<= s10;
esiguiente<= s1; when s10 =>
adelante <= '0'; adelante <= '0';
elsif S =X"2" then atras <= '0';
esiguiente<= s3; giro_izq <= '0';
adelante <= '0'; giro_der <= '1';
elsif S =X"3" then esiguiente<= s11;
esiguiente<= s5; when s11 =>
adelante <= '0'; adelante <= '0';
end if; atras <= '0';
when s1 => giro_izq <= '0';
adelante <= '0'; giro_der <= '1';
atras <= '1'; esiguiente<= s0;
giro_izq <= '0'; when others => null;
giro_der <= '0'; end case;
esiguiente<= s2; out_epresente <= esiguiente;
when s2 => end if;
adelante <= '0'; end process;
atras <= '0'; end Behavioral;
Una vez compilado el código, pasamos a convertir esta máquina en un
símbolo, para después unirlo con otros componentes, como lo son las salidas
(en este caso son los LEDs y los motores), así como también asignar los pines
para las entradas.
Estas entradas serán por medio del push button.
Nuestro diagrama deberá quedar como a continuación se muestre

Unas ves compiladas todas correctamente, pasaremos a hacer la prueba en la

tarjeta FPGA EPM2210F324C3. En esta tarjeta podremos observar que por medio los
switch de entrada podemos observar los Leds de salida (estos nos muestran el estado
en el que estamos).
Una vez que veamos que el programa y la carta ASM funcionan correctamente,
podremos implementar nuestro código en la FPGA conectado al carro.
Al final de esta implementación, podremos observar nuevamente como por
medio de los switches y botones de entrada, las llantas del carro realiza los
cambios de dirección.

Conclusiones:
Gonzales Gonzales Dora Isabel:
Esta práctica nos ayudó a comprender de manera práctica las cartas ASM, así
como pudimos observar en qué estado se localizaba y cuál era la acción que
se tenía que llevar a cabo, en este caso, ya sea girar hacia adelante, atrás,
izquierda, derecha o bien quedarse detenido.

Linares Fuentes Alan:

El desarrollo de esta práctica nos ayudó para entender el funcionamiento
de las cartas ASM ya programado en el lenguaje VHDL e implementado
para controlar un carrito el cual hacíamos que giraran sus ruedas
dependiendo del estado en el que nos encontráramos y metiendo las
condiciones.
Monzalbo Nuñez Jorge:
Con esta práctica aplicamos el conocimiento adquirido acerca de las cartas
ASM, así como su implementación en el lenguaje VHDL y su simulación en el
software QUARTUS. Así como la importancia de las Cartas ASM en el diseño
de robots.
Pozos Pozos Noe:
Al realizar la práctica fortalecimos los conocimientos acerca del lenguaje VHDL
y las cartas ASM, pudimos observar a que estados tenía que ir y las acciones a
realizar, aunque en un principio lo que nos costaba trabajo era poder localizar
él estado en el que nos encontrábamos, pero una vez que pudimos saberlo nos
fue fácil poder cambiar de estados sin ningún problema.

Bibliografía:
https://biorobotics.fi-p.unam.mx/
http://creaciodigital.upf.edu/~smiguel/b13maquinaEstados.htm