Aplicación de máquinas de estado

APLICACIÓN DE MÁQUINAS DE ESTADO

Evelyn Melissa Anaya Lopez

evelyn.lopez@mail.escuelaing.edu.co
Alejandra Bohórquez Casallas
alejandra.bohorquez@mail.escuelaing.edu.co
Maria Valentina Salamanca Parra
mara.salamanca-p@mail.escuelaing.edu.co

​ ESUMEN: ​El principal objetivo de este laboratorio

R
es implementar la lógica operativa y la lógica de control
por medio de un sistema que carga dos números, uno
de partida y otro final; por medio del programa Vivado se
diseñaron cada uno de los elementos necesarios para la
implementación del trabajo y de este modo se pudo
visualizar en la tarjeta programable Basys3, como
resultado se obtuvo un sistema que cargaba un número
y contaba hasta llegar a este y una visualización
dinámica con 4 displays la cual permitía ver los estados,
el contador, el número de partida y número el final.

PALABRAS CLAVE​: Basys3, Lógica de control,

Lógica operativa, Máquina de estados, Registro, Vivado.
1 INTRODUCCIÓN
La información binaria encontrada en un sistema
digital puede estar constituida por datos o información
de control y estado. Los datos son elementos discretos
de información que se manipulan por micro operaciones
elementales como sumar, incrementar, etc., en el
procesador de datos del sistema bajo el mando y
supervisión de la unidad de control. La información de
control suministra las señales de mando adecuadas para
especificar la secuencia en que se deben ir ejecutando
las microoperaciones en el procesador de acuerdo con
el algoritmo establecido [1].
La información de estado son señales generadas
por el procesador de datos hacia la unidad de control
para indicarle a esta última el estado en que se
encuentra el procesador de datos del sistema. La unidad
de control chequea estas señales de estado y de
acuerdo al valor que tengan las mismas toma la decisión
de cuál es la siguiente microoperación que debe ordenar
ejecutar [1].
En la figura 1 se observa el diagrama funcional
general de un sistema digital para el procesamiento de
información. En el mismo se puede observar que a la
unidad de control llegan tanto las señales de estado
como también señales externas al sistema que
igualmente condicionan la siguiente microoperación que
debe ser ejecutada [1].
Figura 1.Sistema digital formado por la unidad de control
y el procesador de datos.
VHDL significa HDL Hardware Description
Language. Se trata de un lenguaje de descripción de
hardware, esto significa que mediante él se puede
describir la forma de comportarse de un circuito
electrónico. El comportamiento puede ser llevado a
algún dispositivo que dispondrá de sus propios
componentes con los que logrará ese comportamiento
deseado. La forma de comportarse es independiente del
hardware donde se implementa [2].
2 DESCRIPCIÓN DEL PROBLEMA
Mediante una lógica operativa y una lógica de
control (​máquina de estados​) se buscó realizar
una implementación en VHDL que cumpliera con
los siguientes requisitos:
-Por medio de interruptores (tipo DIPSW)
introducir dos números de 4 bits, en donde uno de
esos números representa el número de partida y el
otro el número final.
-En un contador programable ascendente
binario, se debe cargar el número de partida y
luego de que se oprima un pulsador de inicio, se
activa un contador hasta que se llegue al número
final, en ese momento debe detenerse el conteo.

1
Aplicación de máquinas de estado
.
-Diseñar en VHDL cada una de las partes
necesarias para la implementación del trabajo y
diseñar un diagrama de bloques general.
-Utilice una tarjeta Digilent (Nexys) para la
implementación final.
-Utilice Vivado para la implementación del
trabajo.
-Debe realizar la entrada al sistema desde los
DIPSW de la tarjeta y desde un pulsador de la
tarjeta.
-Debe realizar la operación de la máquina de
estados basado en un reloj cuya frecuencia sea de
1Hz.
-Los valores inicial y final se deben almacenar en
registros Paralelo/Paralelo y ambos deben
visualizarse en display 7 segmentos.
-El valor actual (estado presente) del contador
debe visualizarse en un display 7 segmentos.
-El valor del estado presente de la máquina de
estados debe verse también en un display 7
segmentos.
3 DISEÑO DE LA SOLUCIÓN DEL
PROBLEMA
Para dar solución al problema lo primero que se hizo fue
pensar en los posibles estados que se pudieran
presentar, para ello, se diseñó la máquina de estados
mostrada en la figura 2, la cual describe una
implementación tipo Moore, en el cual las salidas solo
dependen de los estados.
Figura 2. Máquina de estados
En este caso, la máquina de estados cuenta con cuatro
entradas y cinco salidas. El pulsador y el igual son las
entradas, mientras que las salidas, son los dos
habilitadores de los registros, el habilitador del contador,
el load del mismo y el número del estado. Como primer
estado de la máquina, es decir en reposo, el pulsador
está inactivo y el estado del igual no importa, con
respecto a las salidas todas están inactivas. Para pasar
2
al estado dos o el estado cargar registros, el pulsador
debe de estar activo y el igual no importa en cual estado
esté, en el estado dos o cargar registro los habilitadores
de los registros están activos, ya que el valor de A y de
B, los cuales describen el número desde donde empieza
y termina el conteo, respectivamente, se busca que sean
cargados en los registros paralelos-paralelos,. Para
pasar al estado tres o carga contador el estado del
pulsador y del igual no importa, en este estado la única
salida activa es el load del contador, ya que en este
estado se carga como tal el valor del dato en el
contador. Para finalizar esta máquina de estados, al
pasar al estado cuatro el estado del pulsador y del igual
tampoco importan, en este estado en este estado se
evalúa cómo se encuentra el igual, es decir se comparan
los dos números hasta que sean iguales para poder
comenzar nuevamente con la máquina de estados, acá
se habilita el contador cuando A y B sean iguales.
A partir de este diseño se busca implementarlo en una
FPGA el cual se describe como desarrollo de la práctica.
4 DESARROLLO DE LA PRÁCTICA
El desarrollo de esta práctica se realizó en VIVADO,
utilizando la tarjeta de programación Basys, lo primero
que se realizó en la programación fue el componente de
la máquina de estado de la figura 2, a partir de la lógica
no discreta se habilita o deshabilita las salidas con “0” o
“1”, en todo este proceso se tienen en cuenta dos
señales que se crearon con el fin de identificar el estado
presente y el estado futuro descrito anteriormente, y
también un reset para poder inicializar la máquina
cuando fuera conveniente.
Previamente se creó el flip-flop tipo D, tomando como
base el documento suministrado por el profesor,
teniendo cuatro entradas y una salida, siendo D,
CLEAR, CLK y el habilitador las entradas y Q la
respectiva salida, se tuvo en cuenta el CLEAR de este
para poder tener un reset para poder digitar valores
nuevos de los dos datos cargados. El contador
programable también se creó con el documento
suministrado por el profesor, teniendo como entradas a
el load, el habilitador el reset, el reloj, el registro y D, y
como salida Q, teniendo en cuenta un ciclo para poder
generar el conteo del número inicial al final.
Seguido a esto se creó el comparador, el cual sólo tiene
un ciclo para que pueda generar la salida en cero o en
uno según sea necesario, ya que cuando A y B son igual
la salida (Y) debe de ser “1” o sino un “0”.
Luego se creó el divisor, teniendo en cuenta que la
Basys tiene un reloj interno de 100MHz y por esto el
rango para la creación de este estuvo entre 0 y 50MHz.
El resultado de toda esta programación se evidencia en
las figuras 2, 3, 4, 5 y 6, en las cuales se evidencia el
contador, el dígito A, el B y el estado en el que se
encuentra respectivamente en los displays, para el
ejemplo A fue el número “A” y B el número “2”.
Aplicación de máquinas de estado
.

Figura 5. Estado “0”.

Figura 2. Estado “1”.

Figura 6. Reset activado.

El esquemático obtenido de vivado donde se evidencia

Figura 3. Estado “2”.
la lógica descrita anteriormente se observa en el
apéndice 1.

5 CONCLUSIONES
La implementación de un diagrama de bloques
es fundamental para el desarrollo de cualquier
trabajo que requiera una lógica operativa y de
control
Una máquina de estados permite desarrollar un
orden determinado a la ejecución de diferentes
acciones
Es importante aprender a crear flip-flops de
cualquier tipo (D,T, JK, SR), ya que por medio de
estos se pueden construir diferentes elementos
que requieran de un reloj o contador.

6 REFERENCIAS
Figura 4. Estado “3”.
[1]​Cdn.usc.edu.co,​ 2019. [Online]. Available:
http://cdn.usc.edu.co/files/LABORATORIOS/GUIAS/INGENI
ERIA/INGENIERIA%20EN%20SISTEMAS/CIRCUITOS%20
DIGITALES%20II/LOGICA%20DE%20CONTROL.pdf.
[Accessed: 28- Jan- 2019].

3
Aplicación de máquinas de estado
.

[2]"Programación en VHDL/Introducción - Wikilibros",

Es.wikibooks.org,​ 2019. [Online]. Available:
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_VHDL/I
ntroducci%C3%B3n. [Accessed: 28- Jan- 2019].

APÉNDICE 1

Apéndice 2

4
Aplicación de máquinas de estado
.

Apéndice 3

DIVISOR

entity divisor is
Port ( clk_D : in STD_LOGIC;
clk_1 : inout STD_LOGIC);
end divisor;

architecture Behavioral of divisor is

signal Divisor :INTEGER RANGE 0 TO 50000000;
signal CLKo: std_logic;

begin
process(clk_D) --divisor
begin
if (clk_D'event and clk_D='1') then
if(Divisor = 50000000)then
Divisor<=0;
CLKo <= not CLKo;
else
Divisor <= Divisor + 1;
end if;
end if;
end Process;
clk_1<=CLKo;
end Behavioral;

VISUALIZACIÓN DINÁMICA

entity VIS_BIN_4DIG is
Port ( clkb:in STD_LOGIC;
CLR: IN STD_LOGIC;
BIN2 : inout STD_LOGIC_VECTOR (1 downto 0));
end VIS_BIN_4DIG;
architecture Behavioral of VIS_BIN_4DIG is
signal Divisor :INTEGER RANGE 0 TO 200000;
signal se: std_logic;
SIGNAL PULSOn : STD_LOGIC;
SIGNAL BINn : STD_LOGIC_VECTOR (1 downto 0);

begin
BIN2<=BINn;
process(clkb,CLR,Divisor) --divisor
begin
if (clkb'event and clkb='1') then
if(Divisor = 200000)then
Divisor<=0;
se <= not se;
else
Divisor <= Divisor + 1;
end if;
end if;
PULSOn<=se;
end Process;
process (PULSOn)
begin
if (PULSOn' event and PULSOn='1') then
if BINn="11" OR CLR = '1' then BINn<="00";
else

5
Aplicación de máquinas de estado
.

BINn<=BINn+1;
end if;
end if;
end process;
end Behavioral;

MÁQUINAS DE ESTADO

entity Registros is
port(reset: in std_logic;
clk: in std_logic;
Puls: in std_logic;
igual: in std_logic;
HPP1: inout std_logic;
HPP2: inout std_logic;
HCONT: inout std_logic;
N_estado: inout STD_LOGIC_VECTOR(3 downto 0);
Lcont: inout std_logic);
end Registros;
architecture behavioral of Registros is
TYPE ESTADOS IS (D0,D1,D2,D3);
SIGNAL E_PRE,E_FUT:ESTADOS;
BEGIN
PROCESS(E_PRE,Puls,reset,igual)
begin
case E_PRE is
when D0 =>
HCONT<='0';
LCONT<='0';
N_estado<="0000";
if Puls='1' then
HPP1<='1';
HPP2<='1';
E_FUT<=D1;
else
E_FUT<= D0;
HPP1<='0';
HPP2<='0';
end if;
when D1 =>
if reset='0' then
HPP1<='1';
HPP2<='1';
HCONT<='0';
LCONT<='0';
N_estado<="0001";
E_FUT<=D2;
else
N_estado<="0000";
E_FUT<=D0;
end if;
when D2=>
if reset='0' then
HPP1<='0';
HPP2<='0';
HCONT<='0';
LCONT<='1';
N_estado<="0010";
E_FUT<=D3;
else
N_estado<="0000";

6
Aplicación de máquinas de estado
.

E_FUT<=D0;
end if;
when D3 =>
if reset='0' then
HPP1<='0';
HPP2<='0';
LCONT<='0';
N_estado<="0011";
if igual = '0' then
HCONT<='1';
E_FUT<=D3;
else
N_estado<="0000";
E_FUT<=D0;
HCONT<='0';
end if;
else
E_FUT<=D0;
end if;

end CASE;
end process;

process(clk)
begin
if(clk'event and clk='0')then
E_PRE<=E_FUT;
end if;
end process;
end behavioral;

FLIP-FLOP

entity FFD is
Port ( D : in STD_LOGIC_VECTOR (3 downto 0);
CLEAR : in STD_LOGIC;
CLK : in STD_LOGIC;
habilitador:in std_logic;
Q : out STD_LOGIC_VECTOR (3 downto 0));
end FFD;

architecture Behavioral of FFD is

signal q1: std_logic_VECTOR (3 downto 0);
begin
process (CLK,habilitador)
begin
if ClEAR ='0' then
IF (CLK' EVENT AND CLK='0' and habilitador='1') THEN
q1<= D;
END IF;
else
q1<= "0000";
end if;
Q<=q1;
end process;

end Behavioral;

CONTADOR PROGRAMABLE

7
Aplicación de máquinas de estado
.

entity CONTADOR is
Port ( load : in STD_LOGIC;
hab : in STD_LOGIC;
reset : in STD_LOGIC;
clk : in STD_LOGIC;
regB: in std_logic_vector(3 downto 0);
D : in STD_LOGIC_VECTOR (3 downto 0);
Q : out STD_LOGIC_VECTOR (3 downto 0));
end CONTADOR;

architecture Behavioral of CONTADOR is

signal conteo : std_logic_vector(3 downto 0);
begin
process(clk, load, hab,reset,D)
begin
if reset='1' then conteo<="0000";
else
if load='1' then conteo<=D;
else
if conteo = regB then conteo<=conteo;
else
if (clk' event and clk='1' and hab='1') then
conteo<=conteo + 1;
end if;
end if;
end if;
end if;
end process;

Q<=conteo;

end Behavioral;

COMPARADOR

entity comparador is
port (
A: in std_logic_vector(3 downto 0);
B: in std_logic_vector(3 downto 0);
Y: inout std_logic);
end comparador;
architecture behavioral of comparador is
begin
process(A,B)
begin
if A=B then
Y<='1';
else
Y<='0';
end if;
end process;
end behavioral;

SIETE SEGMENTOS

entity Seven_Segments is
Port ( BCD : in STD_LOGIC_VECTOR (3 downto 0);
rsts: in std_logic;
SAL7SEG: out STD_LOGIC_VECTOR (6 downto 0));

8
Aplicación de máquinas de estado
.

end Seven_Segments;

architecture Behavioral of Seven_Segments is

begin
process (BCD,rsts)
BEGIN
if rsts='1' then
SAL7SEG<="0000001";
else
case BCD is
when "0000" => SAL7SEG <= "0000001"; -- 0
when "0001" => SAL7SEG<= "1001111"; -- 1
when "0010" => SAL7SEG <= "0010010"; -- 2
when "0011" => SAL7SEG <= "0000110"; -- 3
when "0100" => SAL7SEG <= "1001100"; -- 4
when "0101" => SAL7SEG <= "0100100"; -- 5
when "0110" => SAL7SEG <= "0100000"; -- 6
when "0111" => SAL7SEG <= "0001111"; -- 7
when "1000" => SAL7SEG <= "0000000"; -- 8
when "1001" => SAL7SEG <= "0000100"; -- 9
when "1010" => SAL7SEG <= "0001000"; -- A
when "1011" => SAL7SEG <= "1100000"; -- B
when "1100" => SAL7SEG <= "0110001"; -- C
when "1101" => SAL7SEG <= "1000010"; -- D
when "1110" => SAL7SEG <= "0110000"; -- E
when others => SAL7SEG <= "0111000"; -- F
end case;
end if;
END PROCESS;
end Behavioral;

MAIN

entity MAIN is
Port (A: in std_logic_vector(3 downto 0);
B: in std_logic_vector(3 downto 0);
reloj: in std_logic;
btn_reset: in std_logic;
btn_cargar: in std_logic;
seg: out STD_LOGIC_VECTOR(6 downto 0);
displays: out STD_LOGIC_VECTOR(3 downto 0));
end MAIN;

architecture Behavioral of MAIN is

component divisor is
Port ( clk_D : in STD_LOGIC;
clk_1 : inout STD_LOGIC);
end component divisor;

component comparador is
port (
A: in std_logic_vector(3 downto 0);
B: in std_logic_vector(3 downto 0);
Y: inout std_logic);
end component comparador;

component CONTADOR is
Port ( load : in STD_LOGIC;

9
Aplicación de máquinas de estado
.

hab : in STD_LOGIC;
reset : in STD_LOGIC;
clk : in STD_LOGIC;
regB: in std_logic_vector(3 downto 0);
D : in STD_LOGIC_VECTOR (3 downto 0);
Q : out STD_LOGIC_VECTOR (3 downto 0));
end component CONTADOR;

component VIS_BIN_4DIG is
Port ( clkb:in STD_LOGIC;
CLR: IN STD_LOGIC;
BIN2 : inout STD_LOGIC_VECTOR (1 downto 0));
end component VIS_BIN_4DIG;

component FFD is
Port ( D : in STD_LOGIC_VECTOR (3 downto 0);
CLEAR : in STD_LOGIC;
CLK : in STD_LOGIC;
habilitador:in std_logic;
Q : out STD_LOGIC_VECTOR (3 downto 0));
end component FFD;

component Registros is
port(reset: in std_logic;
clk: in std_logic;
Puls: in std_logic;
igual: in std_logic;
HPP1: inout std_logic;
HPP2: inout std_logic;
HCONT: inout std_logic;
N_estado: inout STD_LOGIC_VECTOR(3 downto 0);
Lcont: inout std_logic);
end component Registros;

component Seven_Segments is
Port ( BCD : in STD_LOGIC_VECTOR (3 downto 0);
rsts: in std_logic;
SAL7SEG: out STD_LOGIC_VECTOR (6 downto 0));
end component Seven_Segments;

signal s_clk:std_logic;
signal sigual: std_logic;
signal sHPP1: std_logic;
signal sHPP2: std_logic;
signal slcont: std_logic;
signal shcont: std_logic;
signal sreg1:std_logic_vector(3 downto 0);
signal sreg2:std_logic_vector(3 downto 0);
signal scontador: std_logic_vector(3 downto 0);
signal vis: STD_LOGIC_VECTOR(1 downto 0);
signal display_sel: STD_LOGIC_VECTOR(3 downto 0);
signal sseg :std_logic_vector(3 downto 0);
SIGNAL sestado: std_logic_vector(3 downto 0);

begin
divisor_1HZ: divisor PORT MAP (
clk_D=> reloj,
clk_1=> s_clk );
maquina: Registros PORT MAP (reset=> btn_reset,
clk=> s_clk,
Puls=>btn_cargar,
igual=>sigual,
HPP1=>sHPP1,

10
Aplicación de máquinas de estado
.

HPP2=>sHPP2,
Hcont=>shcont,
N_estado=>sestado,
Lcont=>slcont);
reg1: FFD PORT MAP (D=>A,
CLK=>s_clk,
CLEAR=>btn_reset,
habilitador=>sHPP1,
Q=>sreg1);
reg2: FFD PORT MAP (D=>B,
CLK=>s_clk,
CLEAR=>btn_reset,
habilitador=>sHPP2,
Q=>sreg2);
contador_programable: contador PORT MAP (load=>slcont,
hab=>shcont,
reset=>btn_reset,
clk=>s_clk,
regB => sreg2,
D=>sreg1,
Q=>scontador);
Visualizacion: VIS_BIN_4DIG PORT MAP (clkb=>reloj,
CLR=>btn_reset,
BIN2=>vis);

comparador_l: comparador PORT MAP (A=>scontador,

B=>sreg2,
Y=>sigual);
segm: Seven_Segments PORT MAP(BCD=>sseg,
rsts=>btn_reset,
SAL7SEG=>seg);

displays <= display_sel;

process(vis,display_sel)
begin -- selección del display

case vis is
when "00" =>
display_sel <= "1110"; -- display 0
when "01" =>
display_sel <= "1101"; -- display 1
when "10" =>
display_sel <= "1011"; -- display 2
when others =>
display_sel <= "0111"; -- display 3
end case;

-- mostrar digitos
case display_sel is
when "1110" =>
sseg <= sreg2; -- 0
when "1101" =>
sseg <= sreg1; -- 1
when "1011" =>
sseg<= scontador; -- 2
when others =>
sseg <= sestado;
end case;
end process;
end Behavioral;

11
Aplicación de máquinas de estado
.

12