Tecnológico Nacional de México

Ingeniería Electrónica
Diseño digital con VHDL

Detector de secuencia Moore

Equipo 2
Desarrollo
Integrantes del equipo:

Jorge Carrasco Corral 17060696

Oscar Rubén López Parra 17060698

Daniel Octavio Hernández Méndez 18060111

Jesús Joshua Muñoz Pacheco 18060728

Docente: Ing. Enrique Gerardo Hernández Vega

29/Marzo/2020
Introducción

Objetivos
 La separación del bloque combinacional que determina el próximo estado y
el bloque de memoria F/Fs y que se obtenga una sentencia para cada uno
de esos 2 bloques.
 Comparación en simulaciones de la versión original y la versión que se
creó.

Marco teórico
El modelo Moore es donde las salidas únicamente dependen del estado del
circuito.
El modelo Mealy es aquel cuyas salidas no únicamente dependen del estado del
circuito si no que también estas dependen de las entradas del mismo circuito.

Desarrollo
Se creó un proyecto en el ambiente de desarrollo Xilinx para copiar y analizar
posteriormente el lenguaje descriptivo de la circuitería de un detector de secuencia
con modelo Moore.
Una vez ya fue creado este proyecto se copió del archivo proporcionado por el
docente por medio de la plataforma el contenido de este con el cual se puede
observar la aplicación del modelo Moore, después se procedió a realizar el
objetivo, el cual es la obtención de un bloque combinacional y del bloque de
memoria siendo este último el de los flip-flops y, al mismo tiempo, obtener dos
process para la descripción VHDL del detector de secuencia Moore.
En la descripción en VHDL, para llegar a obtener los dos process, lo que hicimos
fue primero tener las señales Y, actual, siguiente, más las constantes de los
estados A,B,C, se tiene que saber que estas ya no son de tipo state_type como se
ve en la primera versión de este secuenciador de Moore, sino que ahora son
meras constantes de tipo std_logic y, además a estas, se les asignó su valor
binario de estado que se mostró en la clase.
Puesto esto, se colocó el primer process siendo controlado por W y la señal
actual, que es el bloque combinacional que determinará el próximo estado. En
este bloque, se necesita analizar la señal actual y para esto se optó por tener un
case donde la señal actual se analiza para A,B,C donde, dependiendo del valor
que tengamos en W, siendo como únicos posibles valores 0 o 1, dependiendo de
estos estados se realizarán diferentes acciones, si es 0 se devolverá al estado
inicial (A o “00”) pero si es 1 continuará a un estado posterior que será B si
anteriormente fue A y C si anteriormente fue B, además, continuara en C si la
entrada W sigue tomando el valor de 1 consecutivamente. Se termina el case y,
por lo tanto, terminamos el process.
En el segundo bloque, el cual es el bloque de f/fs o bloque de memoria donde
tendremos el clock y el reset. Este bloque incluye una condición reset donde si
este tiene el valor 0 la señal actual de Y se asignara al estado inicial (A o “00”),
usando un elsif para cuando se tenga un evento de reloj y este esté en alto a la
señal actual de Y se le asignará la siguiente señal de Y para que pueda analizarse
en el siguiente case, esto es la memoria, y, como línea final, se añadió una
asignación a la salida Z donde se tiene como condición a un 1 solamente cuando
la señal de Y se encuentre en el estado C u “11”.
Por último, lo realizado fue la simulación tanto con un solo process como con dos
para la comparación en simulación de estas dos descripciones en VHDL.

Resultados
Simulación de la descripción VHDL original.
Simulación y esquemático de la descripción VHDL con dos procesos.

Observamos, por medio de la simulación, que incluso dividiendo en varios bloques

el bloque hibrido que se tiene en el primer archivo hay funcionamiento igual, pero
se debe de dar importancia al hecho de que los esquemáticos son diferentes
siendo relativamente más sencillo el esquemático producido gracias al
secuenciador con los bloques de memoria y combinacionales dividido. De esta
manera llegamos a apreciar cómo se ejecuta el modelo Moore.

Conclusión
Se observó de manera eficaz el funcionamiento de descripción Moore aunque con
respecto al esquemático se vio como el mismo se disminuyó en tamaño puesto
que habíamos hecho dos procesos donde separábamos los f/fs con respecto del
bloque combinacional pero dimos por hecho que la funcionabilidad de ambos es
exactamente igual como se puede apreciar en las simulaciones.

Referencias
https://mecatronic2.wordpress.com/2012/11/07/detector-de-secuencia-maquina-de-estados-
moore/ -- Diego González García 7 de nov.

https://www.academia.edu/4867365/Fundamentos_de_logica_digital_con_diseno_VHDL_-
_Brown_2ed_---HD Fundamentos de lógica digital con diseño VHDL Brown 2ed Pag 533.

Anexos

Archivo descriptivo de la circuitería (VHDL)

-- Instituto Tecnológico de Chihuahua
-- Equipo 2:
-- Jesus Joshua Muñoz Pacheco 18060728
-- Daniel Octavio Hernandez Mendez 18060111
-- Jorge Carrasco Corral 17060696
-- Oscar Ruben Lopez Parra 17060698

-- Fecha de creación: 29.03.2020 16:15

-- Número de práctica: Ninguna
-- Nombre del proyecto: Detector de secuencia de Moore
-- Dispositivo de destino: Ninguno
-- Revisión: 29/03/2020

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity SEC_MOORE_ASIG_ESTD is

Port ( Clock, Reset, w : IN STD_LOGIC ;

z : OUT STD_LOGIC ) ;

end SEC_MOORE_ASIG_ESTD;

architecture Behavioral of SEC_MOORE_ASIG_ESTD is

signal y_actual, y_siguiente : std_logic_vector(1 downto 0); -- las señales y, la actual y la

siguiente
constant A : std_logic_vector(1 downto 0) := "00" ; --Estas constantes son los estados de
AByC
constant B : std_logic_vector(1 downto 0) := "01" ;
constant C : std_logic_vector(1 downto 0) := "11" ;

begin

process ( w, y_actual ) --Bloque de combinacional, este determina el proximo estado

begin
case y_actual is -- case analiza la y actual para A,B y C
when A => --Caso donde es A
if w = '0' then y_siguiente <= A ;-- si es cero se devuelve al estado inicial "00"
else y_siguiente <= B ; --Si es 1 entonces avanza al estado B
end if ;
when B => --Caso donde es B
if w = '0' then y_siguiente <= A ;-- si es cero se devuelve al estado inicial "00"
else y_siguiente <= C ; --Si es 1 entonces avanza al estado C
end if ;
when C => --Caso donde es C
 if w = '0' then y_siguiente <= A ; -- si es cero se devuelve al estado inicial "00"
else y_siguiente <= C ; --Si es 1 entonces continua en el mismo estado C
end if ;
when others => --Otros casos
y_siguiente <= A ; --En este caso se regresa al estado inicial "00"
end case ;
end process ;

process ( Clock, Reset ) -- Bloque de flip flops o bloque de memoria

begin
if Reset = '0' then
y_actual <= A ; -- si Reset esta en 0 a la señal actual de y se le asignara el estado
inicial "00"
elsif (Clock'event and Clock = '1') then
y_actual <= y_siguiente ; --Cuando el clock este en alto a la señal actual de y se le
asignara la
end if ; -- Siguiente señal de y para que pueda analizarce en el case
end process ; --Esta es la memoria.

z <= '1' when y_actual = C else '0' ; --La salida (Z) sera 1 solamente cuando la señal
actual de y sea
-- igual al estado C "11"

end Behavioral;

Test Bench

-- Create Date: 25/09/2018

-- Design Name:
-- Project Name: DetSecMoore
-- VHDL Test Bench for module: DetSecMoore
------------------------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity SEC_MOORE_TB is

end SEC_MOORE_TB;

architecture Behavioral of SEC_MOORE_TB is

component SEC_MOORE
port(Clock, Resetn, w: IN STD_LOGIC;
Z : OUT STD_LOGIC);

end component;
signal Clock: std_logic:= '1';
signal Reset: std_logic:= '0';
signal w: std_logic:= '0';
signal Z: std_logic;

constant clock_period: time:= 10ns;

begin
UUT: SEC_MOORE
 PORT MAP(
Clock => Clock,
Resetn => Reset,
Z => Z,
w => w );

-- Clock process definitions

Clock_process :process
begin
Clock <= '0';
wait for Clock_period/2;
Clock <= '1';
wait for Clock_period/2;
end process;
-- Reset process definitions
Reset_process :process
begin
wait for 13 ns;
Reset <= '1';
wait for Clock_period*20;
Reset <= '0';
wait for 7 ns;
Reset <= '1';
wait;
end process;
-- Stimulus process
w_proc: process
begin
wait for 28 ns;
w <= '1';
wait for Clock_period;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*2;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*3;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period;
----------------------------------------------
w <= '0';
wait for 22 ns;
w <= '1';
wait for Clock_period;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*2;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*3;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period;
w <= '0';
wait for Clock_period*3/2;
w <= '1';
wait for Clock_period;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*2;
w <= '0';
wait for Clock_period;
w <= '1';
wait for Clock_period*3;
end process;

end Behavioral;