diseño de maquinas secuenciales sincronicas

1. 𝑦0
Diseño de máquinas secuenciales sincrónicas
1 ) Dado el diagrama de estados de una maquina sincrónica y la asignación de estados
Formato: S2 , S1/Dir2 , Dir1
Asignación de estados:
𝑦1
0 1
0 a c
1 𝜙 b
Se pide:
1. ASM.
2. Mapas de estado siguiente y salida (ASM a mapas).
3. Tabla de Verdad y mapas de E.S. y salida (D.E. a Tabla y Tabla a mapas).
4. Implementación, con multiplexores y flip-flop tipo D.
5. Código VHDL completo y diagrama de tiempo (simulado).
a
b c
00/00
𝜙0/10
0𝜙/01
10/10 𝜙1/00
01/01
1𝜙/00
Resetn
MSS
S2
S1
clk
Resetn
Dir2
Dir1

2. ASM:
Viendo el diagrama de estados podemos formar el diagrama ASM, solo tenemos que ver
las condiciones de entrada (bloque de decisión) y las salidas que sean 1 (inicio/fin).
Las salidas que tienen un inicio/fin(ovalo), son salidas tipo Mealy, es decir, varían acorde
la condición de entrada.
Resetn
Ta 00
S2
S2
S1 S1
S1
Tb 11 Tc 10
Dir1 Dir2
Dir1 Dir2
1
1
0
0
0
001 1

3. Mapas de Karnaugh
- Para el mapa de estado siguiente, nos posicionamos en un estado cualquiera, el inicial
preferible podría ser… (Ta), y vemos las rutas posibles que tiene este estado al llegar a
otros estados, solo tomamos en cuenta los estados que tengan en su código, el bit de
1 debido a que éste se multiplica por la ecuación resultante en la trayectoria.
En Ta (00):
En el camino rojo vemos que hay unas dos ecuaciones en la posición de 𝑦1:
𝑆2
̅̅̅ 𝑆1 + 𝑆2 𝑆1
̅ = 𝑆2 ⊕ 𝑆1
En la trayectoria azul, hay un solo camino en la posición de 𝑦0:
𝑆2
̅̅̅ 𝑆1
Como no hay más caminos, esta dupla la colocamos en el mapa de Karnaugh en la posición 00
y así continuamos con el siguiente estado:
En Tb (11):
Camino naranja, posición 𝑦1:
𝑺 𝟐
̅̅̅
Camino verde, posición 𝑦0:
𝑆2
̅̅̅
En Tc (10):
Camino morado, posición 𝑦1:
𝑆1
̅
En 𝑦0 no hay presencia de 1 en la trayectoria, entonces es 0

4. 𝑦0
(𝑌1, 𝑌0):
Decodificador de estado siguiente
Para la salida, solo vemos los bloques de inicio/fin (ovalos), ya que estos son 1’s a la salida, así
mismo, nos centramos en un estado, preferible el estado inicial, y ver las trayectorias hacia
otro estado, pero solo en donde haya las condiciones de salida.
La posición la determina la variable de salida acorde al formato establecido.
En la posición de Dir1:
Camino rojo (Ta)
𝑆2
̅̅̅ 𝑆1
Camino verde (Tb)
𝑆2
̅̅̅
En la posición de Dir2:
Camino azul (Ta)
𝑆2 𝑆1
̅
Camino morado (Tc)
𝑆1
̅
𝑦1
0 1
0 𝑆2 ⊕ 𝑆1, 𝑆2
̅̅̅ 𝑆1 𝑆1
̅ , 0
1 𝜙 , 𝜙 𝑺 𝟐
̅̅̅ , 𝑆2
̅̅̅

5. 𝑦0
(𝐷𝑖𝑟2, 𝐷𝑖𝑟1): (deco de salida)
Por tablas de verdad:
E.P. IN E.S. OUT
𝑦1 𝑦0 𝑆2 𝑆1 𝑌1 𝑌0 𝐷𝑖𝑟2 𝐷𝑖𝑟1
0 0 0 0 0 0 0 0
0 0 0 1 1 1 0 1
0 0 1 0 1 0 1 0
0 0 1 1 0 0 0 0
0 1 0 0 𝜙 𝜙 𝜙 𝜙
0 1 0 1 𝜙 𝜙 𝜙 𝜙
0 1 1 0 𝜙 𝜙 𝜙 𝜙
0 1 1 1 𝜙 𝜙 𝜙 𝜙
1 0 0 0 1 0 1 0
1 0 0 1 0 0 0 0
1 0 1 0 1 0 1 0
1 0 1 1 0 0 0 0
1 1 0 0 1 1 0 1
1 1 0 1 1 1 0 1
1 1 1 0 0 0 0 0
1 1 1 1 0 0 0 0
𝑦1
0 1
0 S2S1
̅ , 𝑆2
̅̅̅ 𝑆1 𝑆1 , 0
1 𝝓 , 𝝓 0 , 𝑆2
̅̅̅
𝑌1
0 𝑆2
⊕
𝑆1
1
1
0
𝜙
𝜙𝜙
𝜙
𝜙
1
𝑆1
̅0
1
0
1
𝑆2
̅̅̅1
0
0
𝑌0
0
𝑆2
̅̅̅ 𝑆11
0
0
𝜙
𝜙𝜙
𝜙
𝜙
0
00
0
0
1
𝑆2
̅̅̅1
0
0
𝐷𝑖𝑟2
0
𝑆2 𝑆1
̅0
1
0
𝜙
𝜙𝜙
𝜙
𝜙
1
𝑆10
1
0
0
00
0
0
𝐷𝑖𝑟1
0
𝑆2
̅̅̅ 𝑆11
0
0
𝜙
𝜙𝜙
𝜙
𝜙
0
00
0
0
1
𝑆2
̅̅̅1
0
0

6. 𝑦0
𝑦0
Este método es Variable Entrante al Mapa, la tabla debe ser reducida hasta que tenga las
variables de estado actual, después éstas salidas colocarlas en un mapa de Karnaugh:
Decodificador de Estado Siguiente:
Decodificador de Salida
Si existen demasiadas entradas, no es recomendable hacer una tabla de verdad debido a la
cantidad excesiva de combinaciones que se deben realizar, cuando este problema se presenta,
es recomendable realizar el diagrama ASM y posteriormente realizar los mapas.
𝑦1
0 1
0 𝑆2 ⊕ 𝑆1, 𝑆2
̅̅̅ 𝑆1 𝑆1
̅ , 0
1 𝜙 , 𝜙 𝑺 𝟐
̅̅̅ , 𝑆2
̅̅̅
𝑦1
0 1
0 S2S1
̅ , 𝑆2
̅̅̅ 𝑆1 𝑆1 , 0
1 𝜙 , 𝜙 0 , 𝑆2
̅̅̅

7. Implementación:
𝑦1 𝑦0
0
1
2
3
Y1MUX
8-1
𝑦1 𝑦0
0
1
2
3
Y0MUX
8-1
S2 S1
D
Q
reset
Clock
reset
Clock
Q
D
𝑦1
𝑦0
MUX
8-1
MUX
8-1
0
1
2
3
0
1
2
3
S2
S1
𝑦1 𝑦0
𝑦1 𝑦0
S1
S2
Dir2
Dir1
Clock reset
FF-D
FF-D

8. VHDL:
library ieee;
use ieee.std_logic_1164.all;
-- black box o bloque general con entradas y salidas
entity ejemplo_e_14 is
port(S1,S2,clk,Resetn: in std_logic; Dir1,Dir2: out std_logic);
end ejemplo_e_14;
architecture behaviour of ejemplo_e_14 is
-- estados
type states is (Ta,Tb,Tc);
signal y: states:=Ta;
begin
-- deco de estado siguiente
process(clk,Resetn)
begin
if Resetn = '0' then y <= Ta; -- reset asincrono
elsif clk = '1' and clk'event then --flanco positivo
case y is
when Ta =>
if (S2 = '0' and S1 = '0') or (S2 = '1' and S1 = '1') then
y <= Ta;
elsif S2 = '0' and S1 = '1' then y <= Tb;
elsif S2 = '1' and S1 = '0' then y <= Tc;
end if;
when Tb =>
if S2 = '0' then y <= Tb;
else y <= Ta;
end if;
when Tc =>
if S1 = '0' then y <= Tc;
else y <= Ta;
end if;
end case;
end if;
end process;
-- deco de salida
process (y,S1,S2)
begin
Dir2 <= '0'; Dir1 <= '0';
case y is
when Ta =>
if S2 = '0' and S1 = '1' then Dir1 <= '1';
elsif S2 = '1' and S1 = '0' then Dir2 <= '1';
end if;
when Tb =>
if S2 = '0' then Dir1 <= '1';
end if;
when Tc =>
if S1 = '0' then Dir2 <= '1';
end if;
end case;
end process;
end behaviour;

11. 𝑦2 𝑦1
𝑦0
𝑦2 𝑦1
𝑦0
𝑦2 𝑦1
𝑦0
2 ) Pasar de Mapas a ASM y código VHDL
Datos:
Decodificador de estad siguiente
(𝑌2, 𝑌1, 𝑌0) :
Decodificador de salida
(𝑂3 , 𝑂2 , 𝑂1) :
Para este problema no es necesario la asignación de estado, pero al momento de realizar
el código en VHDL se necesita el nombre de los estados, así le asignaremos los nombres:
00 01 11 10
0
0 , 0 , 𝐼1 0, 𝐼1
̅, 𝐼1 0,0,0 0,1, 𝐼3
1
𝐼2 𝐼1 , 0 , 𝐼2
̅ 𝐼1 0, 𝐼2, 𝐼2 0,0,0 0,0,0
00 01 11 10
0
1 , 0 , 0 𝐼1, 𝐼1
̅, 0 0,0,0 0,0, 𝐼3
1
𝐼2 𝐼1 , 0 , 0 1, 𝐼2
̅, 𝐼2 0,0,0 0,0,0
00 01 11 10
0
Ta Tc Tg Te
1
Tb Td Th Tf

12. Como ya sabemos los nombres para los estados, entonces podemos posicionarnos en el
estado de Ta, evaluaremos primero al mapa de estados, después evaluaremos al de
salida:
Estados Siguientes
En Ta (000)
Vemos que la entrada I1 es la única condición para pasar de un estado a otro o quedarse
en el mismo estado. Continuamos en el siguiente estado Tb
Por intuición y lógica, evaluamos primero a I1 debido a que este esta no-inverso y la
entrada I2 puede tomar cualquier valor, es decir un don’t care.
Seguimos al siguiente estado Tc:
0, 0, I1
0
1
000
001
Ta
Tb
𝐼2 𝐼1 , 0 , 𝐼2
̅ 𝐼1 I1
0
1
000 Ta
𝐼2 , 0 , 𝐼2
̅
0
1
001
100
Tb
Te
0, 𝐼1
̅, 𝐼1
0
1
010 Tc
001 Tb

13. Continuamos con Td:
Continuamos con Te
Para Tf, Tg y Th son estado cero, es decir, los estados anteriores no nos conducen a
éstos, no se los evaluá.
Ahora las salidas
Vemos solo cuando se hace uno en las salidas:
Ta: (es Moore)
Tb:
Tc:
0, 𝐼2, 𝐼2 I2 0
1
000 Ta
011 Td
0,1, 𝐼3 I3 0
1
010 Tc
011 Td
O3
𝐼2 𝐼1 , 0 , 0 I2 0
1
0 0 0
I1 0 0 I1
0
1 O3
𝐼1 , 𝐼1
̅ , 0
0
1
0 1 0
1 0 0
O2
O3
0 0 0

14. Td:
En Td el 1 que está a la salida, representa una salida Moore
Te:
Las demás salidas son cero.
Procedemos a dibujar el ASM
1 , 𝐼2
̅ , 𝐼2
0
1
1 1 0
1 0 1
O2
O1
0 , 0 , 𝐼3
0
1
0 0 0
0 0 1 O1

15. Resetn
𝑂3
𝐼1
𝐼1
𝐼2
𝑂3
𝐼3
𝑂1
𝑂3
𝐼1 𝐼2
𝑂1
𝑂2
𝑂2
𝑂3
Ta 000
1
1
1
1
1
1
0
0
0
0
0
0
Tb 001
Te 100
Td 011Tc 010

16. VHDL:
library ieee;
use ieee.std_logic_1164.all;
entity mapas is
port( I3,I2,I1,clk,resetn : in std_logic;
O3,O2,O1 : out std_logic);
end mapas;
architecture behaviour of mapas is
type estados is (Ta,Tb,Tc,Td,Te);
signal y: estados;
begin
--transiciones
process(clk,resetn)
begin
if resetn = '0' then y <= Ta;
elsif (clk = '1' and clk'event) then
case y is
when Ta =>
if I1 = '0' then y <= Ta;
else y <= Tb; end if;
when Tb =>
if I1 = '0' then y <= Ta;
elsif I2 = '0' then y <= Tb;
else y <= Te; end if;
when Te => --seguii el orden del ASM, no importa
if I3 = '0' then y <= Tc;
else y <= Td; end if;
when Tc =>
if I1 = '0' then y <= Tc;
else y <= Tb; end if;
when Td =>
if I2 = '1' then y <= Td;
else y <= Ta; end if;
end case;
end if;
end process;
--salidas
process(y,I3,I2,I1)
begin
O3 <= '0' ; O2 <= '0' ; O1 <= '0';
case y is
when Ta => O3 <= '1';
when Tb => if I1 = '1' and I2 ='1' then
O3 <= '1';
end if;
when Te => if I3 = '1' then O1 <= '1';
end if;
when Tc => if I1 = '0' then O3 <= '1';
else O2 <= '1'; end if;
when Td => if I2 = '1' then
O3 <= '1' ; O1 <= '1';
else
O3 <= '1' ; O2 <= '1';
end if;
end case;
end process;
end behaviour;

17. Simulación:

18. 3 ) Diseño de un automático para tanque elevado
Diagrama de estado:
Formato: S2, S1 / w
Tabla de estados:
y0 S2 S1 Y0 w
0 0 0 0 0
0 0 1 ф ф
0 1 0 0 0
0 1 1 1 0
1 0 0 0 1
1 0 1 ф ф
1 1 0 1 1
1 1 1 1 1
S2
S1
Señal
de
Voltaje
-Como estado inicial, asumimos el
tanque lleno, entonces, en este
momento S2 = 0 y S1 = 0.
-Medio vacío las señales toman el valor
de S2 = 1 y S1 = 0.
-Y completamente vacío S2 = 1 y S1 = 1,
este es un estado diferente al anterior.
-De vuelta el llenado son los pasos
anteriores, pero al revés, conservando
la salida del estado anterior.
a/0
b/1
𝜙0/0
00/111/0
1𝜙/1
𝑟𝑒𝑠𝑒𝑡𝑛

19. Implementación:
El valor de ‘01’ en las entradas es un valor imposible físicamente, así que se le da un don’t care.
En el estado siguiente (Y0), cuando estamos en el estado ‘a’, al don’t care le damos un valor de
1 para que se parezca a la entrada S1, cuando estamos en ‘b’, al don’t care le damos un valor de
0 para que se parezca a S2.
La salida w cuando y0 es cero, podemos darle el valor de cero al don’t care, cuando y0 es 1, le
damos el valor de 1 al don’t care, hacemos esto para que la salida no dependa de la entrada y
no gastar compuertas (máquina de Moore), en pocas palabras, estamos tomando el valor de y0
como salida.
Código VHDL:
library ieee;
use ieee.std_logic_1164.all;
entity autotank is
port(S1,S2,clk,resetn : in std_logic;
w : out std_logic);
end autotank;
architecture behaviour of autotank is
type states is (a,b);
signal y: states;
begin
process(clk,resetn)
begin
if resetn = '0' then y <= a;
elseif clk = '1' and clk'event then
case y is
when a => if S1 = '0' then y <= a;
elsif S2 = '1' then y <= b;
end if;
when b => if S2 = '1' then y <= b;
elsif S1 = '0' then y <= a;
end if;
end case;
end if;
end process;
process(y,S1,S2)
begin
case y is
when a => w <= '0';
when b => w <= '1';
end case;
end process;
end behaviour;
resetn

20. Resetn
1
1
1
0
0
0
0
1
ASM:
S1
S2
w
S2
S1
Ta 0
Tb 1

21. Simulación en Quartus ii :

22. 4 ) Dado el código en VHDL incompleto y el diagrama de tiempo:
- Grafique el diagrama de estados.
- Código VHDL completo.
Solución:
Tenemos que darnos cuenta que no nos dan el código completo de VHDL, solo nos
proporcionan información de las entradas y salidas y también el código del
decodificador de estado siguiente. Debemos de ver las salidas en el diagrama de tiempo
y ver las salidas que genera cada estado (si es Mealy o Moore)

23. Vemos que, al inicio, en el estado ‘a’ aparecen 0’s y 1’s, cuando A1 = 0 y A2 = 1, W = 1 y
cuando A1 = 1 y A2 = 1, W = 0, también nos percatamos en otro intervalo de tiempo que
cuando A1 = 0 y A2 = 0, W = 0, estas salidas son pertenecientes al estado ‘a’, entonces
‘a’ es Mealy.
En el estado ‘b’ vemos que también es Mealy, con A1 = 1 y A2 = 0, W = 0, con A1 = 1 y
A2 = 1, W = 1, con A1 = 0 y A2 = 0, W = 0.
En el estado ‘c’ vemos también que es Mealy, con A1 = 0 y A2 = 1, W = 0, con A1 = 0 y
A2 = 0, W = 1, con A1 = 1 y A2 = 0, W = 0.
Ahora vemos con qué valor o valores de entrada, pasa al siguiente estado y para eso,
tenemos que ver en cambio en los flancos, vemos que de ‘a’ a ‘b’ se necesita una entrada
de A1 = 1 y A2 = 0, de ‘b’ a ‘c’ se necesita una entrada de A1 = 0 y A2 = 1 y de ‘c’ a ‘a’
A1 = 1 y A2 = 1.
Ahora procedemos a graficar el diagrama de estados.
Formato: A1, A2 / W
Vemos que en el código de VHDL en la parte del decodificador de estado siguiente, en
la parte de ‘when a =>’ el if solo toma en cuenta el valor de A1, entonces el A2 sería un
don’t care, pero después hay un elsif en donde pregunta por A2 pero solo cuando es
cero, en esta parte del elsif, la entrada A1 predeterminadamente toma el valor de 1,
entonces tenemos ‘10/0’, pero, ¿dónde está la combinación de ‘11’?, la salida de ‘0’ con
entradas ‘11’ en el estado ‘a’, debe ser un ‘valor imposible’ físicamente para la máquina
secuencial y por defecto se le ha asignado en el decodificador de salida una salida de
cero en esta combinación para este estado. Revisamos todas las salidas con entrada de
datos imposibles y vemos que en ‘b’ la combinación ‘00’ genera ´0´ en el mismo estado,
también en ‘c’ ‘10/0’ en el mismo estado. El diagrama de estado sería entonces:
a
b c
00/0
01/1
11/0
00/1
01/0
10/0
10/0
11/1
00/0
10/0
01/0
11/1
resetn

24. Formato: A1, A2 / W
Si desarrollasen el ASM de la máquina al principio, se darán cuenta que al llegar a los
bloques de condición al preguntar solo por un valor (0 o 1) de una variable de entrada,
no sabrán a donde colocar la flecha
A1
A2
A2
W
Ta
resetn
1
1
0
1
0
0
Tb
Salida asignada por default
en la codificación en VHDL
11/0

25. Código VHDL completo:
Se usó para el decodificador de salida la declaración “PROCESS, CASE IS, WHEN”
Cómo ven en el decodificador de salida, la salida está asignada con 0 en la línea
32, acorde a las condiciones de entrada, la salida toma los valores de 1, pero para los
valores de entrada que no existen, toman automáticamente los valores de 0 en la salida.

26. Apuntes:
1. Las salidas de un estado en un diagrama de estado no deben ser más de 2 𝑛 𝑖𝑛,
donde 𝑛𝑖𝑛 es el número de entradas de la MSS, el estado puede recibir cualquier
cantidad de entradas.
Formato: x, y / z
2. Las flechas de salidas pueden tener don’t care en sus entradas, pero no en la
salida:
3. Si no hay combinación existente en la salida de un estado, se le asigna don’t
care en el estado siguiente y salida.
a
00/0
01/0 10/0
11/1
Vemos en el formato que el número de
entradas que tiene la MSS son 2(x e y),
entonces 22
= 4 , esto son 4
combinaciones posibles que puede
presentar este estado a la salida, no
puede exceder el número de
combinaciones debido a que las salidas
son únicas.
a
0𝜙/0
10/1
11/1
El don’t care representa 1 o 0, es decir en la
flecha de bucle, tenemos las
combinaciones 00/0 o 01/0, es decir, no
estamos tomando en cuenta la segunda
entrada.
a
b
𝜙0/0
resetn
11/0 00/1
1𝜙/1
𝑦0 𝑋 𝑌 𝑌0 𝑍
a 0 0 a 0
A 0 1 ф ф
A 1 0 a 0
A 1 1 b 0
B 0 0 a 1
b 0 1 ф ф
B 1 0 b 1
B 1 1 b 1

27. Como vemos en el punto 3, la combinación que no existe en la máquina de estado es
cuando X = 0 e Y = 1, la salida se le puede dar cualquier valor, también armando un mapa
de Karnaugh. En La parte del desarrollo del ASM, el bloque de decisión de la entrada que
solo presenta una condición (solo 1 o 0), a la entrada contraria, se la puede asignar a la
salida un 0 y regresar al mismo estado
Aunque en la programación con VHDL se le puede asignar a todas las salidas y que no
están en la descripción como cero si se usara una asignación al inicio en la descripción
del decodificador de salida
--deco de salida
process(y,X,Y)
begin
Z <= '0';
case y is
when b => Z <= '1';
end case;
end process;
end behaviour;
4. El número de flip-flops que se va a usar es igual al techo del logaritmo en base 2
del número de estados:
𝑁𝐹𝐹−𝐷 = ⌈log2(𝑁𝑒𝑠𝑡𝑎𝑑𝑜𝑠)⌉
-Si contamos con 3 estados, entonces necesitamos ⌈1.584⌉ = 2 flip-flops tipo D
- Si tenemos 7 estados, entonces el # de FF-D serían ⌈2.807⌉ = 3 FF-D
Otra forma es aproximar es sabiendo que 2 𝑁 𝐹𝐹 = 𝑁𝑒𝑠𝑡𝑎𝑑𝑜𝑠, podemos dar al # de FF-D un
valor entero máximo aproximado, 2 𝑁 𝐹𝐹 = 7, entonces 𝑁𝐹𝐹 ≈ 3.
Y
X
1
0
1
0
Ta
Siguiente estado

28. 5. El número de estados siguientes, que es igual al número de estados presentes (o
estado actual), es igual a número de flip-flops tipo D y viceversa.
6. La Tabla de estados presentes siguientes se la forma de la siguiente manera.
7. La asignación de estado se la hace con distancia unitaria, eso se logra
transformando los números en binario (# de estados) a código Grey o dando
distancia unitaria a los estados cercanos a un estado.
8. En el ASM, los caminos o flechas, solo me representan ceros en las salidas, si se
especifica un 1 en la salida, se coloca un ‘inicio/fin’ con el nombre de la salida o
salidas si es Mealy, si es Moore, el nombre de la variable de salida o salidas, va
adentro del estado.
9. Los mapas de Karnaugh se reducen de tal forma que se deben ingresar las
entradas de la MSS como variables de entrada al mapa (V.E.M.) y los estados
actuales como variables combinatorias.
Estados presentes entradas Estados siguientes salidas
𝑦𝑛 … … . . 𝑦1 𝑦0 𝑠𝑡𝑎𝑟𝑡 𝑒𝑛 𝑙𝑑 … . 𝑥 𝑝 𝑎 𝑏 𝑌𝑛 … … . . 𝑌1 𝑌0 𝑂3 𝑄 𝑛 … . 𝑂𝑘 𝐸𝑟𝑟
Estado con una salida O3 = 1
Salida condicional. Solo
cuando I1 toma el valor de 0,
el estado Tc entrega solo a
O2 = 1.

29. Variables combinatorias
Variables entrantes al mapa
El siguiente mapa representa 2 mapas en uno, la coma separa a Y1 y a Y0.
Se los hace de esta manera para utilizar un MUX, las variables de estado
presentes quedan como selectores de dato y las entradas en el MUX van
conectadas a la combinación respectiva que presenta cada cuadro.
Vemos en el primer MUX que
hay una compuerta XOR, es la
combinación en el casillero 00
de Y1, así sucesivamente se va
implementando las
combinaciones hasta formar el
decodificador de estado
siguiente con su respectiva
memoria (registro de
sostenimiento o flip-flop D)

30. 10. Combinaciones útiles
11. La reducción de estado se la puede realizar con un mapa de Karnaugh
comparando los estados que se pueden repetir junto con sus salidas, si se repite,
el código de estado es reemplazado con el que se ha comparado en la repetición
de estados
𝐴 𝐵 𝐴 + 𝐵
0 0 0
0 1 1
1 0 1
1 1 1
𝐴 𝐵 𝐴 𝐵
0 0 0
0 1 0
1 0 0
1 1 1
𝐴 𝐵 𝐴⨁𝐵
0 0 0
0 1 1
1 0 1
1 1 0
𝐴 𝐵 𝐴 + 𝐵̅̅̅̅̅̅̅̅
0 0 1
0 1 0
1 0 0
1 1 0
𝐴 𝐵 𝐴⨀𝐵
0 0 1
0 1 0
1 0 0
1 1 1
𝐴 𝐵 𝐴 𝐵̅̅̅̅̅
0 0 1
0 1 1
1 0 1
1 1 0
𝐴 𝐵 𝐴 𝐵̅
0 0 0
0 1 0
1 0 1
1 1 0
𝐴 𝐵 𝐴̅ 𝐵
0 0 0
0 1 1
1 0 0
1 1 0
иванович