Instituto Politcnico

Nacional
Unidad Profesional Interdisciplinaria
D

de Ingeniera y Tecnologas Avanzadas.

Materia : Dispositivos Lgicos Programables
Nombre de los integrantes:
Mata Mireles Hector Omar
Edgar Eduardo Martinez
Sandoval Mendoza Manuel
Grupo: 2mv12.
Nombre del profesor: Trejo Salazar David
Benjamin
Reporte: Practica 2 (Maquinas de estado)

OBJETIVO
El objetivo de esta prctica es aplicar la teora vista en clase sobre las mquinas de estado
mealy y moore, para esto se resolvern tres ejercicios, los cuales se mostrara en el
desarrollo de la prctica, el cdigo en lenguaje VHDL implementado en la tarjeta Nexys 2.

MARCO TEORICO
Las mquinas de Mealy y Moore son circuitos sncronos. Un circuito sncrono es un
circuito digital en el cual sus partes estn sincronizadas por una seal de reloj. En un
circuito sncrono ideal, cada cambio en los diferentes niveles lgicos es simultneo.
Estas transiciones se realizan despus de un cambio de nivel de una seal llamada reloj.
Idealmente la entrada a cada elemento de almacenamiento alcanza su valor final antes de
que la siguiente seal de reloj ocurra, por lo tanto el comportamiento de un circuito se
puede predecir exactamente.
Se requiere de cierto retardo para cada operacin lgica, por lo que existe una mxima
rapidez en el que cada sistema sncrono puede responder. El anlisis de un diagrama de
tiempos puede darnos esta rapidez.

Una mquina de Mealy es una mquina de estados finita, donde las salidas estn
determinadas por el estado actual y la entrada. Esto significa que en el diagrama de
estados se incluye una seal de salida para cada arista de transicin. Por ejemplo, en la
trayectoria de un estado 1 a un estado 2, si la entrada es cero la salida puede ser uno, y se
debe poner sobre la arista la etiqueta 0/1.

Figura 1: Diagrama de estados de una mquina de estados mealy simple.

El nombre Moore machine viene de su promotor: Edward F. Moore, un pionero de las

mquinas de estados, quien escribi Gedanken-experiments on Sequential Machines, pp
129 153, Estudios de Autmatas, Anales de los Estudios Matemticos, no. 34, Princeton
University Press, Princeton, N. J., 1956.
En contraste, la salida de una mquina de estado finito Moore (mquina de Moore),
depende solo del estado actual y no depende de la entrada actual. Por lo tanto, los
estados de una mquina de Moore son la unin de los estados de la mquina de Mealy y
el producto cartesiano de estos estados y alfabeto de entrada (posibles entradas).

Figura 2: Modelo Moore

Figura 3: Tabla de caractersticas de mquinas de estado mealy y moore.

PROCEDIMIENTO Y DESARROLLO
1.- Disear un identificador de secuencia de una entrada de bit serial, a travs de
mquinas de estado de Mealy y Moore, la secuencia q se desea encontrar en la cadena de
bits es la 010110. Cuando se encuentre dicha secuencia la maquina terminara su ciclo;
para corroborar el funcionamiento del diseo la entrada de relej deber ser controlada
por el usuario.

En el ejercicio 1 se utilizaron mquinas de estados de mealy y de moore, la cual se utiliza

para identificar la secuencia de entrada que pide en el ejercicio que es 010110, en este
caso utilizamos los estados e0,e1,e2,e3,e4,e5
en mealy y en moore
S1,S2,S3,S4,S5,S6,S7para el nmero de datos y otro para la alarma la cual funciona o se
activa siempre y cuando se haya cumplido la secuencia, a continuacin se muestra el
cdigo hecho en VHDL

CODIGO MOORE
-- Materia: Dispositivos Lgicos Programables
-- Create Date: 3:31:18 17/04/2014
-- Project Name: Prctica Num. 2
-- Description: Programa cdigo Moore

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

Port ( clk,rst,ent,push : in STD_LOGIC;

alarm : out STD_LOGIC);
end moore;
architecture a_moore of moore is
type estados is (S1,S2,S3,S4,S5,S6,S7);
signal e_p : estados := S1;
signal e_f : estados;
signal flag : std_logic;
begin

func : process (e_p, ent) begin

case e_p is

when S1 => alarm <= '0';

if (ent = '0') then
e_f <= S2;
else
e_f <= S1;
-----------------------------end if;
when S2 => alarm <= '0';
if (ent = '0') then
e_f <= S2;
else
e_f <= S3;
-----------------------------end if;

when S3 => alarm <= '0';

if (ent = '0') then
e_f <= S4;
else
e_f <= S1;
-----------------------------end if;
when S4 => alarm <= '0';
if (ent = '0') then
e_f <= S2;
else
e_f <= S5;
-----------------------------end if;
when S5 => alarm <= '0';
if (ent = '0') then
e_f <= S4;
else
e_f <= S6;
-----------------------------end if;
when S6 => alarm <= '0';
if (ent = '0') then
e_f <= S7;
else
e_f <= S1;
------------------------------

end if;
when S7 => alarm <= '1';
if (ent = '0') then
e_f <= S2;
else
e_f <= S1;
-----------------------------end if;
end case;
end process func;
tiempo: process (clk, push)
variable cont : integer range 0 to 5000000;
begin

if (clk'event and clk = '1') then

if (push = '1') then
flag <= '1';
elsif (flag <= '1') then
cont := cont +1;
end if;
if (cont = 5000000) then
flag <= '0';
cont := 0;
end if;
end if;
end process tiempo;
process (flag,rst,e_f)

begin

if (rst = '1') then

e_p <= S1;

elsif (flag'event and flag = '0') then

e_p <= e_f;

end if;
end process;
end a_moore;

UCF
net alarma loc=L15;
net clk loc=B8;
net push loc=E18;
net rst loc=r17;
net ent loc=B18;

CODIGO MEALY
-- Materia: Dispositivos Lgicos Programables
-- Create Date: 5:25:18 17/04/2014
-- Project Name: Prctica Num. 2
-- Description: Programa cdigo Moore

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity mealy is port
(
push, ent, clk, rst:in std_logic;
alarma: out std_logic
);
end mealy;
architecture Behavioral of mealy is
type misestados is (e0,e1,e2,e3,e4,e5);
signal edoP: misestados:= e0;
signal edoF: misestados;
signal flag: std_logic;
begin
process(ent,edop) begin
alarma<='0';
case(edop) is
when e0 =>
if (ent = '0') then
edof <= e1;
else

edof <= e0;

end if;
---------------------------when e1=>
if(ent = '0')then
edof<=e1;
else
edof<=e2;
end if;
------------------------------when e2 =>
if (ent = '0') then
edof <= e3;
else
edof <= e0;
end if;
------------------------------when e3 =>
if (ent = '0') then
edof <= e3;
else
edof <= e4;
end if;
-------------------------------when e4 =>
if (ent = '0') then

edof <= e3;

else
edof <= e5;
end if;
------------------------------when e5 =>
if (ent = '0') then
edof <= e0;
alarma <= '1';
else
edof <= e0;
end if;
end case;
end process;
tiempo: process (clk, push)
variable cont : integer range 0 to 5000000;
begin
if (clk'event and clk = '1') then
if (push = '1') then
flag <= '1';
elsif (flag <= '1') then
cont := cont +1;
end if;

if (cont = 5000000) then

flag <= '0';
cont := 0;

end if;
end if;
end process tiempo;
------------------------process (flag,rst,edof)
begin

if (rst = '1') then

edop <= e0;

elsif (flag'event and flag = '0') then

edop <= edof;

end if;
end process;
-------------------------end Behavioral;

2.- Disear el Control Digital de un teclado matricial de 4x4, con prioridad del ms alto,
implementar un mtodo a travs de mquinas de estados, si se detecta una tecla
presionada detener el funcionamiento hasta que el usuario suelte la tecla, mostrar en un
display de 7 segmentos la tecla que se presion.

En este programa se utilizaron 4 estados (e0,e1,e2,e3), los cuales se activa mediante la

entrada de reloj definida como B8, que es el cristal que ocupa la nexys, adems se
declaran en el programa las constantes que son las teclas que trae el teclado matricial,
cada que se presiona la una tecla se hace un paro y se muestra en el display tal como lo
menciona el ejercicio 2.

CODIGO EJERCICIO 2
library IEEE;
1164.ALL;
ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity teclitas is port (
clk:in std_logic;
tecla:in std_logic_vector (3 downto 0);
tecla_salida:out std_logic_vector (3 downto 0);
segmento : out STD_LOGIC_VECTOR(6 downto 0));
end teclitas;
architecture Behavorial of teclitas is
constant VACIO : std_logic_vector(6 downto 0):="1111111";
constant CERO : std_logic_vector(6 downto 0):="0000001";
constant UNO : std_logic_vector(6 downto 0):="1001111";

constant DOS : std_logic_vector(6 downto 0):="0010010";

constant TRES : std_logic_vector(6 downto 0):="0000110";
constant CUATRO : std_logic_vector(6 downto 0):="1001100";
constant CINCO : std_logic_vector(6 downto 0):="0100100";
constant SEIS : std_logic_vector(6 downto 0):="0100000";
constant SIETE : std_logic_vector(6 downto 0):="0001111";
constant OCHO : std_logic_vector(6 downto 0):="0000000";
constant NUEVE : std_logic_vector(6 downto 0):="0001100";
constant A : std_logic_vector(6 downto 0):="0001000";
constant B : std_logic_vector(6 downto 0):="1100000";
constant C : std_logic_vector(6 downto 0):="0110001";
constant D : std_logic_vector(6 downto 0):="1000010";
constant AST : std_logic_vector(6 downto 0):="1011010";
constant GAT : std_logic_vector(6 downto 0):="1101100";
type estados is(e0,e1,e2,e3);
barrido : integer range 0 to 1250:=0;
signal auxbarrido : std_logic:='0';

pres:estados;
edo_fut:estados;
signal tecla_barrido:std_logic_vector(3 downto 0);

begin

proc_barrido : process(clk) begin

if rising_edge(clk) then
barrido<=barrido+1;
if barrido=1250 then
barrido<=0;
auxbarrido<=not auxbarrido;
end if;
end if;
end process proc_barrido;
futuro : process(auxbarrido,tecla_barrido,clk) begin
if rising_edge(auxbarrido) then
edo_pres<=edo_fut;
tecla_salida<=tecla_barrido;
end if;
end process futuro;
presente : process(edo_pres, tecla) begin
case (edo_pres) is
when e0 =>
tecla_barrido<="0001";
if (tecla="1000") then
segmento <= UNO;
edo_fut <= e1;
elsif(tecla="0100")then
segmento <= DOS;

edo_fut <= e1;

elsif (tecla="0010")then

segmento <= TRES;

edo_fut <= e1;
elsif (tecla="0001")then
segmento <= A;
edo_fut <= e1;
else
segmento <= VACIO;
edo_fut <= e1;
end if;
when e1 =>
tecla_barrido<="0010";
if (tecla="1000") then
segmento <= AST;--CUATRO;
edo_fut <= e2;
elsif(tecla="0100")then
segmento <= CERO;--DOS;--CINCO;
edo_fut <= e2;
elsif (tecla="0010")then
segmento <=GAT;
edo_fut <= e2;
elsif (tecla="0001")then
segmento <= D;--B;
edo_fut <= e2;
else
segmento <= VACIO;
edo_fut <= e2;
end if;

when e2 =>
tecla_barrido<="0100";
if (tecla="1000") then
segmento <= SIETE;
edo_fut <= e3;
elsif(tecla="0100")then
segmento <= OCHO;
edo_fut <= e3;
elsif (tecla="0010")then
segmento <= NUEVE;
edo_fut <= e3;
elsif (tecla="0001")then
segmento <= C;
edo_fut <= e3;
else
segmento <= VACIO;
edo_fut <= e3;
end if;
when e3 =>
tecla_barrido<="1000";
if (tecla="1000") then
segmento <= CUATRO;
edo_fut <= e0;
elsif(tecla="0100")then
segmento <= CINCO;--CERO;
edo_fut <= e0;
elsif (tecla="0010")then

segmento <=SEIS;
edo_fut <= e0;
elsif (tecla="0001")then
segmento <= B;
edo_fut <= e0;
else
segmento <= VACIO;
edo_fut <= e0;
end if;
end case;
end process presente;
end Behavorial;

UCF

NET segmento[6] LOC = L18;

NET segmento[5] LOC = F18;
NET segmento[4] LOC = D17;
NET segmento[3] LOC = D16;
NET segmento[2] LOC = G14;
NET segmento[1] LOC = J17;
NET segmento[0] LOC = H14;
NET clk LOC = B8;
NET tecla_salida[0] LOC = L15;
NET tecla_salida[1] LOC = K12;
NET tecla_salida[2] LOC = L17;
NET tecla_salida[3] LOC = M15;

NET tecla[3] LOC = M13;

NET tecla[2] LOC = R18;
NET tecla[1] LOC = R15;
NET tecla[0] LOC = T17;

3.- Disear el controlador de una mquina expendedora de tarjetas telefnicas. Existen

tarjetas de $30 y $40 pesos. Consideren un botn selector s, tal que, si s = 0 se
selecciona la tarjeta de $30 y, si s = 1 ser la de $40 pesos. La mquina acepta nicamente
monedas de $10 y $20 pesos, solo una a la vez. Considera una seal de entrada para cada
moneda, siendo 1 lgico el indicativo de la presencia de la misma. La mxima cantidad
que puede recibir es de $50 pesos y debe dar cambio si lo hay. Mientras la maquina este
en uso un led debe de prenderse.

Para el presente ejercicio definimos los estados que ocuparamos de acuerdo a lo que pide
el ejercicio 3, para esto se ocuparon 14 estados los cuales son:
I,A1,A2,A3,A4,A5,A6,B1,B2,B3,B4,B5,B6,E

CODIGO 3
library IEEE;
1164.ALL;
ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Maquina is Port(
clk,rst,push,selec,p10,p20: in std_logic;
error,tarjeta,c10,c20: out std_logic);
end Maquina;
architecture mealy of Maquina is
type state is (I,A1,A2,A3,A4,A5,A6,B1,B2,B3,B4,B5,B6,E);
signal ep:state:=I;
signal ef:state;
signal flag:std_logic;
signal cont:std_logic_vector (18 downto 0);
begin
func:process(ep,selec,p10,p20)
begin
case ep is

when I=>
if(selec='0')then ef<=A1;
else ef<=B1;
end if;
error<='0';
tarjeta<='0';

c10<='0';
c20<='0';
when A1=>
if(p10='1')then ef<=A2;
elsif(p20='1')then ef<=A3;
else ef<=A1;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when A2=>
if(p10='1')then ef<=A3;
elsif(p20='1')then ef<=A4;
else ef<=A2;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';

when A3=>
if(p10='1')then ef<=A4;
elsif(p20='1')then ef<=A5;
else ef<=A3;

end if;

error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when A4=>
if(p10='1')then ef<=A5;
elsif(p20='1')then ef<=A6;
else ef<=A4;
end if;
error<='0';
tarjeta<='1';
c10<='0';
c20<='0';
when A5=>
if(p10='1')then ef<=A6;
elsif(p20='1')then ef<=E;
else ef<=A5;
end if;

error<='0';
tarjeta<='1';
c10<='1';
c20<='0';
when A6=>

if(p10='1')then ef<=E;
elsif(p20='1')then ef<=E;
else ef<=A6;
end if;
error<='0';
tarjeta<='1';
c10<='0';
c20<='1';
when B1=>
if(p10='1')then ef<=B2;
elsif(p20='1')then ef<=B3;
else ef<=B1;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when B2=>
if(p10='1')then ef<=B3;
elsif(p20='1')then ef<=B4;
else ef<=B2;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when B3=>

if(p10='1')then ef<=B4;
elsif(p20='1')then ef<=B5;
else ef<=B3;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when B4=>
if(p10='1')then ef<=B5;
elsif(p20='1')then ef<=B6;
else ef<=B4;
end if;
error<='0';
tarjeta<='0';
c10<='0';
c20<='0';
when B5=>
if(p10='1')then ef<=B6;
elsif(p20='1')then ef<=I;
else ef<=B5;
end if;
error<='0';
tarjeta<='1';
c10<='0';
c20<='0';
when B6=>

if(p10='1')then ef<=E;
elsif(p20='1')then ef<=E;
else ef<=B6;
end if;
error<='0';
tarjeta<='1';
c10<='1';
c20<='0';
when E=>
ef<=E;
error<='1';
tarjeta<='0';
c10<='0';

c20<='0';
end case;
end process func;
tiempo: process(clk,push)
begin
if(clk'event and clk='1')then
if(push='1')then flag<='1';
elsif(flag='1')then cont<=cont+1;
if(cont=x"7A120")then

flag<='0';
cont<=x"0000"&o"0";
end if;

end if;
end if;
end process tiempo;
process(flag,rst,ef)
begin
if(rst='1') then ep<=I;
elsif(flag'event and flag='1')then ep<=ef;
end if;
end process;
end mealy;

UCF
NET clk LOC = B8;
NET error LOC = R4;
NET p10 LOC = K18;
NET p20 LOC = H18;
NET push LOC = H13;

NET rst LOC = R17;

NET selec LOC =G18;
NET tarjeta LOC = J14;
NET c10 LOC = j15
NET c20 LOC = K15

CONCLUSIONES:
Mata Mireles Hctor Omar
En esta prctica pudimos resolver los ejercicios propuestos, adems se dio un repaso de
las mquinas de estado mealy y moore vistas en circuitos lgicos, tambin aprend acerca
del funcionamiento del teclado matricial.
Con respecto a las maquinas hay muchas aplicaciones y se pueden desarrollar proyectos
como lo puede ser un robot escalador, el cual mediante una secuencia y una entrada de
reloj hace un determinado movimiento, este es una de las muchas aplicaciones, ya
depender de la necesidad que se tenga para hacer un proyecto que utilice mquinas de
estados.

Sandoval Mendoza Manuel.

Se utilizaron mquinas de estado, las cuales sirven para ver los diferentes pasos dentro
del proceso. Solo cuando se cumpla uno, se va al siguiente y as sucesivamente, esto se
hace con dos mquinas de estado llamadas una mealy y otra moore, por lo que se tiene
diferentes formas de respuesta aunque muy parecidas, debido a que solo cambia en que
la moore cierra el ciclo de la mquina y mealy no.
Tambin pudimos visualizar que las mquinas de estados sirven para programar
diferentes tipos de dispositivos ya que estn en orden ascendente en actividad.

Martnez Luis Edgar Eduardo.

En esta prctica logramos diferenciar entre un circuito secuencial y uno combinacional as como
su implementacin, esto se logr mediante la programacin de un sumador y un restador de 3 bits
mostrando los resultados en los display tambin se dise un contador de 0 a 99 con una
frecuencia de 10hz, aparte de esto se logr realizar contador a diferentes frecuencias cual cuales
se definieron por los requisitos de profesor, la parte que ms se nos complico fue el uso del
teclado matricial el cual fue un poco complicado de descubrir su correcto funcionamiento pero al
final aprendimos el sistema de coordenadas que utiliza para lograr reconocer las teclas que se
presionan.

BIBLIOGRAFIA:
http://nuevainge.galeon.com/automatasmoore.pdf
http://bloganalisis1.files.wordpress.com/2011/01/apuntesdsd10_
mealy_moore.pdf