Electrónica digital

1. Circuit Design
with VHDL
Volnei A. Pedroni

2. State Machines 163
8Maquinas de estado
Las máquinas de estados finitos (FSM) constituyen una técnica de modelado especial
para circuitos lógicos secuenciales. Tal modelo puede ser muy útil en el diseño de
ciertos tipos de sistemas, particularmente aquellos cuyas tareas forman una secuencia
bien definida (controladores digitales, por ejemplo). Comenzamos el capítulo
revisando los conceptos fundamentales relacionados con los FSM. A continuación,
presentamos las correspondientes técnicas de codificación VHDL, seguidas de
ejemplos completos de diseño.
8.1 Introduccion
La Figura 8.1 muestra el diagrama de bloques de una máquina de estados monofásica.
Como se indica en la fi gura, la sección inferior contiene la lógica secuencial (fl ip- fl
ops), mientras que la sección superior contiene la lógica combinatoria. La sección
combinatoria (superior) tiene dos entradas, siendo un pr_state (estado presente) y el
otro la entrada externa propiamente dicha. También tiene dos salidas, nx_state
(próximo estado) y la salida externa propiamente dicha. La sección secuencial
(inferior) tiene tres entradas (reloj, reinicio y nx_estado) y una salida (pr_state). Dado
que todos los fl ip-fl ops están en esta parte del sistema, el reloj y el reinicio deben
estar conectados a él. Si la salida de la máquina depende no solo del estado actual
sino también de la entrada actual, se llama una máquina Mealy. De lo contrario, si
depende solo del estado actual, se llama máquina Moore. Los ejemplos de ambos se
mostrarán más adelante. La separación del circuito en dos secciones (figura 8.1)
también permite dividir el diseño en dos partes. Desde una perspectiva VHDL, está
claro que la parte inferior, al ser secuencial, requerirá un PROCESO, mientras que la
parte superior, al ser combinada, no lo hará. Sin embargo, recuerde que el código
secuencial puede implementar ambos tipos de lógica, combinacional y secuencial. Por
lo tanto, si se desea, la parte superior también se puede implementar usando un
PROCESO. El reloj de señales y el reinicio normalmente aparecen en la lista de
sensibilidad del PROCESO de la sección inferior (a menos que el restablecimiento
sea síncrono o no se use, o se use WAIT en lugar de SI). Cuando se restablece el
restablecimiento, pr_state se establecerá en el estado inicial del sistema. De lo
contrario, en el borde del reloj apropiado, flip-fl ops almacenará nx_state,
transfiriéndolo así a la salida de la sección inferior (pr_state). Un aspecto importante
relacionado con el enfoque FSM es que, aunque cualquier circuito secuencial puede,

3. State Machines 163
en principio, ser modelado como una máquina de estado, esto no siempre es
ventajoso. La razón es que el código puede volverse más largo, más complejo y más
propenso a errores que en un enfoque convencional. Este es a menudo el caso con
registro simple
Figure 8.1
Mealy (Moore) state machine diagram.
circuitos, como contadores. Como regla general, el enfoque FSM es aconsejable en
sistemas cuyas tareas constituyen una lista bien estructurada para que todos los
estados puedan ser fácilmente enumerados. Es decir, en una implementación de
máquina de estados típica, al inicio de la ARQUITECTURA, encontraremos un tipo
de datos enumerados definidos por el usuario, que contienen una lista de todos los
posibles estados del sistema. Los controladores digitales son buenos ejemplos de tales
circuitos.
Otro aspecto importante, que ya se destacó al comienzo del capítulo 5, es que no
todos los circuitos que poseen memoria son necesariamente secuenciales. Se
proporcionó una RAM (memoria de acceso aleatorio) como ejemplo. En él, la
operación de lectura de memoria depende únicamente de los bits de dirección
actualmente aplicados a la RAM (entrada de corriente), y el valor recuperado no tiene
nada que ver con accesos de memoria previos (entradas previas). En tales casos, el
enfoque FSM no es aconsejable.
input output
pr_state nx_state
clock
reset
Sequential
logic
Combinational
logic

4. State Machines 163
8.2 Estilo de diseño #1
Se pueden concebir varios enfoques para diseñar un FSM. Describiremos en detalle
un estilo que está bien estructurado y es fácilmente aplicable. En ella, el diseño de la
sección inferior de la máquina de estado (figura 8.1) está completamente separado del
de la sección superior. Todos los estados de la máquina siempre se declaran
explícitamente utilizando un tipo de datos enumerados. Después de presentar un estilo
de diseño así, lo examinaremos a partir de una información perspectiva de
almacenamiento, para comprender mejor y refinar su construcción, lo que conducirá a
un estilo de diseño n. ° 2.
Diseño de la Sección Inferior (Secuencial)
En la fi gura 8.1, las flip- flops están en la sección inferior, por lo que el reloj y el
reinicio están conectados a ella. La entrada de la otra sección inferior es nx_state
(estado siguiente), mientras que pr_state (estado presente) es su única salida. Siendo
el circuito de la sección inferior secuencial, se requiere un PROCESO, en el que se
puede emplear cualquiera de las declaraciones secuenciales (IF, WAIT, CASE o
LOOP, capítulo 6).
Una plantilla de diseño típica para la sección inferior es la siguiente:
PROCESO (reinicio, reloj) COMIENCE
IF (reset = '1') ENTONCES
pr_state <= state0;
ELSIF (clock'EVENT AND clock = '1') ENTONCES
pr_state <= nx_state; TERMINARA SI;
PROCESO FINALIZADO;
El código mostrado arriba es muy simple. Consiste en un restablecimiento
asincrónico, que determina el estado inicial del sistema (estado0), seguido del
almacenamiento síncrono de nx_state (en la transición positiva del reloj), que
producirá pr_state en la salida de la sección inferior (figura 8.1) . Una cosa buena de
este enfoque es que el diseño de la sección inferior es básicamente estándar.
Otra ventaja de este estilo de diseño es que la cantidad de registros es mínima. De la
sección 7.5, sabemos que el número de fl ip-fl ops inferidas del código anterior es
simplemente igual al número de bits necesarios para codificar todos los estados de la
FSM (porque la única señal a la que se asigna un valor en la transición de otra la señal
es pr_state). Por lo tanto, si se usa el estilo de codificación predeterminado (binario)
(sección 8.4), entonces solo será necesario dlog2ne fl ip- fl ops, donde n es el número
de estados.

5. State Machines 163
Diseño de la Sección Superior (Combinacional)
En la figura 8.1, la sección superior es completamente combinacional, por lo que su
código no necesita ser secuencial; código concurrente también puede ser utilizado.
Sin embargo, en la plantilla de diseño que se muestra a continuación, se empleó un
código secuencial, con la sentencia CASE desempeñando un papel central. En este
caso, recuerde que deben observarse las reglas 1 y 2 de la sección 6.10.
PROCESS (input, pr_state)
BEGIN
CASE pr_state IS
WHEN state0
=>
IF (input = ...) THEN
output <= <value>;
nx_state <= state1;
ELSE ...
END IF;
WHEN state1 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
WHEN state2 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
...
END
CASE;

6. State Machines 163
END
PROCESS;
Como se puede ver, este código también es muy simple y hace dos cosas: (a) asigna
el valor de salida y (b) establece el siguiente estado. Observe también que cumple con
las reglas 1 y 2 de la sección 6.10, relativas al diseño de circuitos combinatorios que
utilizan declaraciones secuenciales, para todas las señales de entrada están presentes
en la lista de sensibilidad y todas las combinaciones de entrada / salida están
especificadas. Finalmente, observe que no se asigna ninguna señal en la transición de
otra señal, por lo que no se deducirán fl ip-fl ops (sección 7.5). Plantilla de máquina
de estado para estilo de diseño n.º 1 Una plantilla completa se muestra a continuación.
Observe que, además de los dos procesos presentados anteriormente, también
contiene un tipo de datos enumerados definidos por el usuario (aquí llamado estado),
que enumera todos los estados posibles de la máquina.

7. State Machines 163
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------
ENTITY <entity_name> IS
PORT ( input: IN <data_type>;
reset, clock: IN STD_LOGIC;
output: OUT <data_type>);
END <entity_name>;
-----------------------------------------------------
ARCHITECTURE <arch_name> OF <entity_name> IS
TYPE state IS (state0, state1, state2, state3, ...);
SIGNAL pr_state, nx_state: state;
BEGIN
---------- Lower section: ------------------------
PROCESS (reset, clock)
BEGIN
IF (reset='1') THEN
pr_state <= state0;
ELSIF (clock'EVENT AND clock='1') THEN
pr_state <= nx_state;
END IF;
END PROCESS;
---------- Upper section: ------------------------
PROCESS (input, pr_state)
BEGIN
CASE pr_state IS
WHEN state0 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state1;
ELSE ...
END IF;
WHEN state1 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
WHEN state2 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state3;
ELSE ...
END IF;
...
END CASE;
END PROCESS;
END <arch_name>;

8. State Machines 167
rst
Figure 8.2
States diagram of example 8.1.
Example8.1: BCD Counter
Un contador es un ejemplo de máquina Moore, ya que la salida depende únicamente
del estado almacenado (presente). Como un simple circuito registrado y como un
secuenciador, se puede implementar fácilmente en cualquiera de los enfoques:
convencional (como ya lo hemos hecho en capítulos anteriores) o tipo de FSM. El
problema con este último es que cuando el número de estados es grande, resulta
engorroso enumerarlos todos, un problema que se evita fácilmente utilizando la
instrucción LOOP en un enfoque convencional.
El diagrama de estado de un contador circular de 0 a 9 se muestra en la figura 8.2.
Los estados se llamaron cero, uno, ..., nueve, cada nombre corresponde al valor
decimal de la salida.
A continuación, se presenta un código VHDL, que se asemeja directamente a la
plantilla de estilo de diseño # 1. Un tipo de datos enumerados (estado) aparece en las
líneas 11-12. El diseño de la sección inferior (cronometrada) se presenta en las líneas
16-23, y el de la sección superior (combinacional), en las líneas 25-59. En este
ejemplo, el número de registros es dlog210e ¼ 4.
Los resultados de la simulación se muestran en la figura 8.3. Como se puede ver, la
salida (recuento) crece de 0 a 9, y luego se reinicia desde 0 nuevamente.
two
(0010)
three
(0011)
one
(0001)
four
(0100)
zero
(0000)
five
(0101)
nine
(1001)
eight
(1000)
seven
(0111)
six
(0110)

9. State Machines 167
1 -------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------------------------
5 ENTITY counter IS
Figure 8.3
Simulation results of example 8.1.
6 PORT ( clk, rst: IN STD_LOGIC;
7 count: OUT STD_LOGIC_VECTOR (3 DOWNTO 0));
8 END counter;
9 -------------------------------------------------
10 ARCHITECTURE state_machine OF counter IS
11 TYPE state IS (zero, one, two, three, four,
12 five, six, seven, eight, nine);
13 SIGNAL pr_state, nx_state: state;
14 BEGIN
15 ------------- Lower section: -----------------
16 PROCESS (rst, clk)
17 BEGIN
18 IF (rst='1') THEN
19 pr_state <= zero;
20 ELSIF (clk'EVENT AND clk='1') THEN
21 pr_state <= nx_state;
22 END IF;
23 END PROCESS;
24 ------------- Upper section: -----------------

10. State Machines 167
25 PROCESS (pr_state)
26 BEGIN
27 CASE pr_state IS
28 WHEN zero =>
29 count <= "0000";
30 nx_state <= one;
31 WHEN one =>
32 count <= "0001";
33 nx_state <= two;
34 WHEN two =>
35 count <= "0010";
36 nx_state <= three;
37 WHEN three =>
38 count <= "0011";
39 nx_state <= four;
40 WHEN four =>
41 count <= "0100";
42 nx_state <= five;
43 WHEN five =>
44 count <= "0101";
45 nx_state <= six;
46 WHEN six =>
47 count <= "0110";
48 nx_state <= seven;
49 WHEN seven =>
50 count <= "0111";
51 nx_state <= eight;
52 WHEN eight =>
53 count <= "1000";
54 nx_state <= nine;
55 WHEN nine =>
56 count <= "1001";
57 nx_state <= zero;

11. State Machines 167
stateA
(x=a)
stateB
(x=b)
d=1
FSM
58 END CASE;
59 END PROCESS;
60 END state_machine;
61 -------------------------------------------------
Example 8.2: Simple FSM #1
La figura 8.4 muestra el diagrama de estados de un FSM muy simple. El sistema tiene
dos estados (stateA y stateB), y debe cambiar de uno a otro cada vez que se recibe d
¼ '1'. La salida deseada es x ¼ a cuando la máquina está en estado A, o x ¼ b cuando
está en estado B. El estado inicial (reinicio) es stateA. A continuación se muestra un
código VHDL para este circuito, que emplea el estilo de diseño n. ° 1.
1 ----------------------------------------------
2 ENTITY simple_fsm IS
a
b x
d=0
d
d=
1
d=0

12. State Machines 169
clk rst rst
Figure 8.4
State machine of example 8.1.
3 PORT ( a, b, d, clk, rst: IN BIT;
4 x: OUT BIT);
5 END simple_fsm;
6 ----------------------------------------------
7 ARCHITECTURE simple_fsm OF simple_fsm IS
8 TYPE state IS (stateA, stateB);
9 SIGNAL pr_state, nx_state: state;
10 BEGIN
11 ----- Lower section: ----------------------
12 PROCESS (rst, clk)
13 BEGIN
14 IF (rst='1') THEN
15 pr_state <= stateA;
16 ELSIF (clk'EVENT AND clk='1') THEN
17 pr_state <= nx_state;
18 END IF;
19 END PROCESS;
20 ---------- Upper section: -----------------
21 PROCESS (a, b, d, pr_state)
22 BEGIN
23 CASE pr_state IS
24 WHEN stateA
=> 25 x <= a;
26 IF (d='1') THEN nx_state <= stateB;
27 ELSE nx_state <= stateA;
28 END IF;
29 WHEN stateB
=> 30 x <= b;

13. State Machines 169
Figure 8.5
Simulation results of example 8.2
31 IF (d='1') THEN nx_state <= stateA;
32 ELSE nx_state <= stateB;
33 END IF;
34 END CASE;
35 END PROCESS;
36 END simple_fsm;
37 ----------------------------------------------
Los resultados de simulación relativos al código anterior se muestran en la figura 8.5.
Tenga en cuenta que el circuito funciona como se esperaba. De hecho, mirando los
archivos de informes, uno verificará que, como se esperaba, solo se requirió una fl ip-
fl op para implementar este circuito porque solo hay dos estados para codificar.
Observe también que la sección superior es de hecho combinacional, ya que la salida
(x), que en este caso depende de las entradas (aob, dependiendo de en qué estado se
encuentre la máquina), varía cuando varían ayb, sin importar clk. Si se requiriera una
salida sincrónica, se debería emplear el estilo de diseño n. ° 2.

14. State Machines 169
Logic gates
Logic gates
8.3 Estilo de diseño n. ° 2 (Salida almacenada)
Como hemos visto, en el estilo de diseño n. ° 1 solo se almacena pr_state. Por lo
tanto, el circuito general puede resumirse como en la figura 8.6 (a). Observe que en
este caso, si se trata de una máquina Mealy (una cuya salida depende de la entrada
actual), la salida puede cambiar cuando la entrada cambie (salida asíncrona).
En muchas aplicaciones, se requiere que las señales sean síncronas, por lo que la
salida debe actualizarse solo cuando se produce el borde del reloj adecuado. Para
hacer que las máquinas Mealy sean síncronas, la salida también debe almacenarse,
como se muestra en la figura 8.6 (b). Esta estructura es el objeto del estilo de diseño #
2.
Para implementar esta nueva estructura, se necesitan muy pocas modificaciones. Por
ejemplo, podemos usar una señal adicional (por ejemplo, temperatura) para calcular
el valor de salida (sección superior).
input
outp
ut
input output

15. 170 Chapter 8
Flip-flops
(a) (b)
Figure 8.6
Circuit diagrams for (a) Design Style #1 and (b) Design Style #2.
pero solo pasa su valor a la señal de salida real cuando ocurre un evento de reloj
(sección inferior). Estas modi fi caciones se pueden observar en la plantilla que se
muestra a continuación.
Plantilla de máquina de estado para estilo de diseño n.º 2
Flip-flops
Flip-flops
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------------------
ENTITY <ent_name> IS
PORT (input: IN <data_type>;
reset, clock: IN STD_LOGIC;
output: OUT <data_type>);
END <ent_name>;
-------------------------------------------------------
ARCHITECTURE <arch_name> OF <ent_name> IS
TYPE states IS (state0, state1, state2, state3, ...);
SIGNAL pr_state, nx_state: states;
SIGNAL temp: <data_type>;
BEGIN
---------- Lower section: --------------------------
PROCESS (reset, clock)
BEGIN
IF (reset='1') THEN
pr_state <= state0;
ELSIF (clock'EVENT AND clock='1') THEN
output <= temp;
pr_state <= nx_state;
END IF;
END PROCESS;

16. 170 Chapter 8
Comparando la plantilla del estilo de diseño # 2 con la del estilo de diseño # 1,
verificamos que las únicas diferencias son las relacionadas con la introducción de la
temperatura de la señal interna. Esta señal causará que se almacene la salida de la
máquina de estado, ya que su valor se pasa a la salida solo cuando ocurre clk'EVENT.
Ejemplo 8.3: FSM simple n. ° 2
Consideremos el diseño del ejemplo 8.2 una vez más. Sin embargo, digamos que
ahora queremos que la salida sea sincrónica (para cambiar solo cuando el reloj suba).
Como se trata de una máquina Mealy, se requiere un estilo de diseño n. ° 2.
1 ----------------------------------------------
2 ENTITY simple_fsm IS
3 PORT ( a, b, d, clk, rst: IN BIT;
4 x: OUT BIT);
5 END simple_fsm;
6 ----------------------------------------------
7 ARCHITECTURE simple_fsm OF simple_fsm IS
8 TYPE state IS (stateA, stateB);
9 SIGNAL pr_state, nx_state: state;
10 SIGNAL temp: BIT;
---------- Upper section: --------------------------
PROCESS (pr_state)
BEGIN
CASE pr_state IS
WHEN state0 =>
temp <= <value>;
IF (condition) THEN nx_state <= state1;
...
END IF;
WHEN state1 =>
temp <= <value>;
IF (condition) THEN nx_state <= state2;
...
END IF;
WHEN state2 =>
temp <= <value>;
IF (condition) THEN nx_state <= state3;
...
END IF;
...
END CASE;
END PROCESS;
END <arch_name>;

17. 172 Chapter 8
11 BEGIN
12 ----- Lower section: ----------------------
13 PROCESS (rst, clk)
14 BEGIN
15 IF (rst='1') THEN
16 pr_state <= stateA;
17 ELSIF (clk'EVENT AND clk='1') THEN
18 x <= temp;
19 pr_state <= nx_state;
20 END IF;
21 END PROCESS;
22 ---------- Upper section: -----------------
23 PROCESS (a, b, d, pr_state)
24 BEGIN
25 CASE pr_state IS
26 WHEN stateA =>
27 temp <= a;
28 IF (d='1') THEN nx_state <= stateB;
29 ELSE nx_state <= stateA;
30 END IF;
31 WHEN stateB =>
32 temp <= b;
33 IF (d='1') THEN nx_state <= stateA;
34 ELSE nx_state <= stateB;
35 END IF;
36 END CASE;
37 END PROCESS;
38 END simple_fsm;
39 ----------------------------------------------

18. 172 Chapter 8
Al observar los archivos de informe producidos por el compilador, observamos que
ahora se dedujeron dos fl ip-fl ops, una para codificar los estados de la máquina y la
otra para almacenar la salida.
Los resultados de la simulación se muestran en la figura 8.7. Recuerde que cuando se
almacena una señal, su valor permanecerá necesariamente estático entre dos bordes
de reloj consecutivos. Por lo tanto, si la entrada (a o b en el ejemplo anterior) cambia
durante este intervalo, el cambio puede no ser observado por el circuito; además,
cuando se observa, se retrasará con respecto a la entrada (que es propia de los
circuitos síncronos).
Figure 8.7
Simulation results of example 8.3.
rst zer
o
(q=
0)
d
=
0 d=1
d=0
one
(q=0)
d=0
d=0
d=1
three
(q=1)
two
(q=0)
d=1
d=1

19. 174 Chapter 8
Figure 8.8
States diagram for example 8.4.
Ejemplo 8.4: Detector de cadenas Queremos diseñar un circuito que tome como
entrada un flujo de bits en serie y genere un '1' siempre que ocurra la secuencia '' 111
''. Las superposiciones también deben considerarse, es decir, si. . . 0111110. . . ocurre,
entonces la salida debe permanecer activa durante tres ciclos de reloj consecutivos. El
diagrama de estado de nuestra máquina se muestra en la figura 8.8. Hay cuatro
estados, que llamamos cero, uno, dos y tres, con el nombre correspondiente al número
de '1' consecutivos detectados. La solución que se muestra a continuación utiliza el
estilo de diseño n. ° 1.
1 --------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------------
5 ENTITY string_detector IS
6 PORT ( d, clk, rst: IN BIT;
7 q: OUT BIT);
8 END string_detector;
9 --------------------------------------------
10 ARCHITECTURE my_arch OF string_detector IS
11 TYPE state IS (zero, one, two, three);
12 SIGNAL pr_state, nx_state: state;
13 BEGIN
14 ----- Lower section: --------------------
15 PROCESS (rst, clk)
16 BEGIN
17 IF (rst='1') THEN
18 pr_state <= zero;
19 ELSIF (clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;

20. 174 Chapter 8
22 END PROCESS;
23 ---------- Upper section: ---------------
24 PROCESS (d, pr_state)
25 BEGIN
26 CASE pr_state IS
27 WHEN zero =>
28 q <= '0';
29 IF (d='1') THEN nx_state <= one;
30 ELSE nx_state <= zero;
31 END IF;
32 WHEN one =>
33 q <= '0';
34 IF (d='1') THEN nx_state <= two;
35 ELSE nx_state <= zero;
36 END IF;
37 WHEN two =>
38 q <= '0';
39 IF (d='1') THEN nx_state <= three;
40 ELSE nx_state <= zero;
41 END IF;
42 WHEN three =>
43 q <= '1';
44 IF (d='0') THEN nx_state <= zero;
45 ELSE nx_state <= three;
46 END IF;
47 END CASE;
48 END PROCESS;
49 END my_arch;
50 --------------------------------------------

21. 174 Chapter 8
Tenga en cuenta que en este ejemplo, la salida no depende de la entrada actual. Este
hecho se puede observar en las líneas 28, 33, 38 y 43 del código anterior, que
muestran que todas las asignaciones a q son incondicionales (es decir, no dependen de
d). Por lo tanto, la salida es automáticamente sincrónica (una máquina Moore), por lo
que el uso del estilo de diseño n. ° 2 es innecesario. El circuito requiere dos fl ip-fl
ops, que codifican los cuatro estados de la máquina de estados, a partir de los cuales
se computa q. Los resultados de la simulación se muestran en la figura 8.9. Como se
puede ver, la secuencia de datos d ¼ '' 011101100 '' se aplicó al circuito, dando como
resultado la respuesta q ¼ '' 000100000 '' en la salida. Ejemplo 8.5: Controlador de luz
Tra ‰ c (TLC) Como se mencionó anteriormente, los controladores digitales son
buenos ejemplos de circuitos que se pueden implementar de manera eficiente cuando
se modelan como máquinas de estado. En el presente ejemplo, queremos diseñar un
TLC con las características resumidas en la tabla de la figura 8.10, es decir:
● Tres modos de operación: Regular, Prueba y En espera.
● Modo regular: cuatro estados, cada uno con un tiempo programable e
independiente, pasan al circuito por medio de CONSTANTE.
● Modo de prueba: permite sobrescribir todos los tiempos preprogramados (mediante
un interruptor manual) con un valor pequeño, de modo que el sistema pueda probarse
fácilmente durante el mantenimiento (1 segundo por estado). Este valor también debe
ser programable y pasar al circuito usando un CONSTANTE.
● Modo de espera: si está configurado (por un sensor que acusa un mal
funcionamiento, por ejemplo, o un interruptor manual), el sistema debe activar las
luces amarillas en ambas direcciones y permanecer así mientras la señal de espera
esté activa.
● Suponga que está disponible un reloj de 60 Hz (obtenido de la línea de
alimentación).

22. State Machines 175
State
Operation Mode
REGULAR TEST STANDBY
Time Time Time
RG timeRG (30s) timeTEST (1s) ---
RY timeRY (5s) timeTEST (1s) ---
GR timeGR (45s) timeTEST (1s) ---
YR timeYR (5s) timeTEST (1s) ---
YY --- --- Indefinite
Figure 8.9
Simulation results of example 8.4.
timeGR
stby
stby
timeRG
R
Y
G
R
Y
G
timeRY GR timeGR
RY timeRY YR
timeYR
timeRG
RG timeYR
YY

23. State Machines 175
Figure 8.10
Specifications and states diagram (regular mode) for example 8.5.

24. 176 Chapter 8
Aquí, el estilo de diseño # 1 puede ser empleado, como se muestra en el siguiente
código.
1 -------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------------------------
5 ENTITY tlc IS
6 PORT ( clk, stby, test: INSTD_LOGIC;
7 r1, r2, y1, y2, g1, g2: OUTSTD_LOGIC);
8 END tlc;
9 -------------------------------------------------
10 ARCHITECTURE behavior OF tlc IS
11 CONSTANT timeMAX : INTEGER := 2700;
12 CONSTANT timeRG : INTEGER := 1800;
13 CONSTANT timeRY : INTEGER := 300;
14 CONSTANT timeGR : INTEGER := 2700;
15 CONSTANT timeYR : INTEGER := 300;
16 CONSTANT timeTEST : INTEGER := 60;
17 TYPE state IS (RG, RY, GR, YR,YY);
18 SIGNAL pr_state, nx_state: state;
19 SIGNAL time : INTEGER RANGE 0 TOtimeMAX;
20 BEGIN
21 -------- Lower section of state machine:----
22 PROCESS (clk, stby)
23 VARIABLE count : INTEGER RANGE 0 TOtimeMAX;
24 BEGIN
25 IF (stby='1') THEN
26 pr_state <= YY;
27 count := 0;
28 ELSIF (clk'EVENT AND clk='1') THEN

25. 176 Chapter 8
29 count := count + 1;
30 IF (count = time) THEN
31 pr_state <= nx_state;
32 count := 0;
33 END IF;
34 END IF;
35 END PROCESS;

26. State Machines 183
36 -------- Upper section of state machine:----
37 PROCESS (pr_state, test)
38 BEGIN
39 CASE pr_stateIS
40 WHEN RG =>
41 r1<='1'; r2<='0'; y1<='0'; y2<='0'; g1<='0';g2<='1';
42 nx_state <= RY;
43 IF (test='0') THEN time <=timeRG;
44 ELSE time <= timeTEST;
45 END IF;
46 WHEN RY =>
47 r1<='1'; r2<='0'; y1<='0'; y2<='1'; g1<='0';g2<='0';
48 nx_state <= GR;
49 IF (test='0') THEN time <=timeRY;
50 ELSE time <= timeTEST;
51 END IF;
52 WHEN GR =>
53 r1<='0'; r2<='1'; y1<='0'; y2<='0'; g1<='1';g2<='0';
54 nx_state <= YR;
55 IF (test='0') THEN time <=timeGR;
56 ELSE time <= timeTEST;
57 END IF;
58 WHEN YR =>
59 r1<='0'; r2<='1'; y1<='1'; y2<='0'; g1<='0';g2<='0';
60 nx_state <= RG;
61 IF (test='0') THEN time <=timeYR;
62 ELSE time <= timeTEST;
63 END IF;
64 WHEN YY =>

27. State Machines 183
65 r1<='0'; r2<='0'; y1<='1'; y2<='1'; g1<='0';g2<='0';
66 nx_state <= RY;
67 END CASE;
68 END PROCESS;
69 END behavior;
70 ----------------------------------------------------
El número esperado de fl ip-fl ops requerido para implementar este circuito es 15; tres
para almacenar pr_state (la máquina tiene cinco estados, por lo que se necesitan tres
bits para codificar ellos), más doce para el contador (es un contador de 12 bits, ya que
debe contar hasta timeMAX ¼ 2700).
Los resultados de la simulación se muestran en la figura 8.11. Para que los resultados
se ajusten adecuadamente en los gráficos, adoptamos valores de tiempo pequeños,
con todas las CONSTANTS igual a 3 excepto timeTEST, que se hizo igual a 1. Por lo
tanto, se espera que el sistema cambie de estado cada tres ciclos de reloj cuando esté
en Regular operación, o cada ciclo de reloj si está en modo Prueba. Estos dos casos se
pueden observar en los primeros dos gráficos de la figura 8.11, respectivamente. El
tercer gráfico muestra el modo de espera activado. Como era de esperar, stby es
asíncrono y tiene mayor prioridad que la prueba, lo que hace que el sistema
permanezca en estado YY (estado 4) mientras que stby está activo. La señal de
prueba, por otro lado, es sincrónica, pero no necesita esperar a que se active el tiempo
actual del estado para finalizar, como se puede observar en el segundo gráfico.
Ejemplo 8.6: Generador de señal
Queremos diseñar un circuito que, desde una señal de reloj clk, dé origen a la señal de
salida mostrada en la figura 8.12 (a). Observe que el circuito debe operar en ambos
bordes (subir y bajar) de clk.
Para eludir el aspecto de dos bordes (sección 6.9), una alternativa es implementar dos
máquinas, una que opera exclusivamente en la transición positiva de clk y otra que
opera exclusivamente en el borde negativo, generando así las señales intermedias
out1 y out2. presentado en la figura 8.12 (b). Estas señales se pueden AND para dar
origen a la señal deseada outp. Tenga en cuenta que este circuito no tiene entradas
externas (excepto por clk, por supuesto), por lo que la salida solo puede cambiar
cuando clk cambia (salida síncrona).

28. State Machines 183
1 -----------------------------------------
2 ENTITY signal_gen IS
3 PORT ( clk: IN BIT;
4 outp: OUT BIT);
5 END signal_gen;
6 -----------------------------------------
7 ARCHITECTURE fsm OF signal_gen IS
8 TYPE state IS (one, two, three);
9 SIGNAL pr_state1, nx_state1: state;
10 SIGNAL pr_state2, nx_state2: state;
11 SIGNAL out1, out2: BIT;
12 BEGIN

29. State Machines 183
Figure 8.11
Simulation results of example 8.5.
clk
outp
(a)
(b)
Figure 8.12
Waveforms of example 8.6: (a) signal outp to be generated from clk
and (b) intermediate signals out1 and out2 (outp ¼ out1 AND out2).
13 ----- Lower section of machine #1: ---
clk
out1
st1 st2 st3
out2
st1 st2 st3
outp

30. State Machines 183
14 PROCESS(clk)
15 BEGIN
16 IF (clk'EVENT AND clk='1') THEN
17 pr_state1 <= nx_state1;
18 END IF;
19 END PROCESS;
20 ----- Lower section of machine #2: ---
21 PROCESS(clk)
22 BEGIN
23 IF (clk'EVENT AND clk='0') THEN
24 pr_state2 <= nx_state2;
25 END IF;
26 END PROCESS;
27 ---- Upper section of machine #1: -----
28 PROCESS (pr_state1)
29 BEGIN
30 CASE pr_state1 IS
31 WHEN one =>
32 out1 <= '0';
33 nx_state1 <= two;
34 WHEN two =>
35 out1 <= '1';
36 nx_state1 <= three;
37 WHEN three =>
38 out1 <= '1';
39 nx_state1 <= one;
40 END CASE;
41 END PROCESS;
42 ---- Upper section of machine #2: -----
43 PROCESS (pr_state2)
44 BEGIN
45 CASE pr_state2 IS
46 WHEN one =>

31. State Machines 183
47 out2 <= '1';
48 nx_state2 <= two;
49 WHEN two =>
50 out2 <= '0';
51 nx_state2 <= three;
52 WHEN three =>
53 out2 <= '1';
54 nx_state2 <= one;
55 END CASE;
56 END PROCESS;
57 outp <= out1 AND out2;
58 END fsm;
59 ------------------------------------------
Los resultados de la simulación del circuito sintetizado con el código anterior se
muestran en la figura 8.13
8.3 Estilo de codificación: de binario a OneHot
Para codificar los estados de una máquina de estados, podemos seleccionar uno entre
varios estilos disponibles. El estilo predeterminado es binario. Su ventaja es que
requiere la menor cantidad de
Figure 8.13
Simulation results of example 8.6.

32. State Machines 183
Table 8.1
State encoding of an 8-state FSM.
Encoding
Style
STATE BINARY TWOHOT ONEHOT
state0 000 00011 00000001
state1 001 00101 00000010
state2 010 01001 00000100
state3 011 10001 00001000
state4 100 00110 00010000
state5 101 01010 00100000
state6 110 10010 01000000
state7 111 01100 10000000
fl ip- fl ops. En este caso, con n fl ip- fl ops (n bits), se pueden codificar hasta 2n
estados. La desventaja de este esquema de codificación es que requiere más lógica y
es más lento que los demás. En el otro extremo está el estilo de codificación onehot,
que usa un fl ip-fl op por estado. Por lo tanto, exige la mayor cantidad de fl ip-fl ops.
En este caso, con n fl ip- fl ops (n bits), solo se pueden codificar n estados. Por otro
lado, este enfoque requiere la menor cantidad de lógica adicional y es el más rápido.
Un estilo que está entre los dos estilos anteriores es el esquema de codificación
twohot, que presenta dos bits activos por estado. Por lo tanto, con n fl ip- fl ops (n
bits), se pueden codificar hasta n (n - 1) / 2 estados. El estilo onehot se recomienda en
aplicaciones donde fl ip-fl ops son abundantes, como en FPGA (Field Programmable
Gate Arrays). Por otro lado, en los ASIC (circuitos integrados específicos de
aplicación), generalmente se prefiere el estilo binario. Como ejemplo, diga que
nuestra máquina de estado tiene ocho estados. Entonces la codificación sería la que se
muestra en la tabla 8.1. El número de fl ip-fl ops requerido en cada caso es de tres
(para binario), cinco (twohot) u ocho (onehot). Otros detalles también se presentan en
la tabla.

33. State Machines 183
rst inp=0
inp
state1
(outp
=00)
inp
=1
state2
(outp=01)
inp=1
inp=0
inp
=1
inp=0
state4
(outp=11)
state3
(outp
=10)
inp=1 inp
=0
Figure P8.1
8.3 Problemas
Cada solución a los problemas propuestos a continuación debe ir acompañada de
síntesis y resultados de simulación. Verifique, al menos, lo siguiente: número de fl ip-
fl ops inferidas y funcionalidad del circuito. Problema 8.1: FSM Escriba un código
VHDL que implemente el FSM descrito por el diagrama de estados de la figura P8.1.
Problema 8.2: Generador de señales n. ° 1 Usando el enfoque de FSM, diseñe un
circuito capaz de generar las dos señales representadas en la figura P8.2 (out1, out2) a
partir de una señal de reloj clk. Las señales son periódicas y tienen el mismo período.
Sin embargo, mientras uno solo cambia en el borde ascendente de clk, el otro tiene
cambios en ambos bordes.

34. 184 Chapter 8
Problema 8.3: Generador de señal n. ° 2
Diseñe una máquina de estado finito capaz de generar dos señales, ARRIBA y
ABAJO, como se ilustra en la figura P8.3. Estas señales están controladas por dos
entradas, GO y STOP. Cuando GO cambia de '0' a '1', la salida UP debe ir también a
'1', pero T ¼ 10 ms después. Si GO vuelve a '0', entonces UP debe regresar a '0'
inmediatamente. Sin embargo, la salida ABAJO ahora debe ir a '1', otra vez 10 ms
más tarde, volviendo a '0' inmediatamente si
clk
out
1
out2
Figure P8.2
GO
STO
P
clk
UP
DO
WN
ST
OP
1 period
T
Signal
Generator

35. 184 Chapter 8
G
O
UP
DOWN
Figure P8.3
GO cambia a '1'. Si se confirma la entrada STOP, ambas salidas deben ir a '0' de
forma inmediata e incondicional. Supongamos que hay disponible un reloj de 10 kHz.
Problema 8.4: Teclado Debouncer y Encoder
Considere el teclado que se muestra en el diagrama de la figura P8.4. Una forma
común de leer una tecla es mediante una técnica llamada escaneo o sondeo, que
reduce la cantidad de cables necesarios para interconectar el teclado al circuito
principal. Consiste en enviar una columna a la vez, mientras lee cada fila
secuencialmente. Si se presiona una tecla, la fila correspondiente será baja, mientras
que las otras permanecerán altas (debido a las resistencias pull-up).

36. State Machines 185
out
p
inp dig
it
data
ASCI
I
01
1
0111 1 31h
1011 4 34h
1101 7 37h
1110 * 2Ah
10
1
0111 2 32h
1011 5 35h
1101 8 38h
1110 0 30h
11
0
0111 3 33h
1011 6 36h
1101 9 39h
1110 # 23h
Figure P8.4
VDD
1
4
7
*
2
5
8
0
3
6
9
# outp2
outp1
outp0
inp4
new_data
inp3
data6
...
data1
data0
inp1
inp2

37. 9 Codificación: cada dígito debe codificarse utilizando el código ASCII (7
bits, con los valores hexadecimales correspondientes listados en la tabla de
la figura P8.4). Cuando hay una nueva lectura disponible en la salida, el bit
new_data debe establecerse en '1'. Esto evitará interpretar una tecla
presionada durante mucho tiempo como una larga serie del mismo
personaje.
10 Eliminación de rebotes: un problema inherente a los interruptores
mecánicos es el rebote del interruptor, que ocurre antes de que se
establezca definitivamente un contacto firme. El asentamiento
generalmente toma unos pocos milisegundos. Por lo tanto, la elección de la
frecuencia del reloj es muy importante. Se le pedirá que lo elija de modo
que se produzcan al menos tres lecturas en un intervalo de 5 ms. Por lo
tanto, el bit new_data debe volverse alto solo cuando se obtenga el mismo
resultado en todas las lecturas consecutivas dentro de un intervalo de 5 ms.
11 Problema 8.5: Controlador de luz Tra ‰ c
12 Usando su herramienta de síntesis más un kit de desarrollo CPLD / FPGA,
implemente el TLC del ejemplo 8.5. Verifique, en los archivos de informe
generados por su software, qué pins del chip se asignaron a las entradas
(clk, stby, test) y a las salidas (r1, y1, g1, r2, y2, g2). Luego haga las
siguientes conexiones físicas en su tablero:
13 ● una señal de onda cuadrada de 60 Hz (desde un generador de señal), con
los niveles lógicos apropiados, al pin clk.
14 ● un interruptor VDD / GND para pin stby.
15 ● un interruptor VDD / GND para probar el pin.
16 ● un LED (rojo, si es posible), con una resistencia de serie de 330-1kohm,
para pin r1 (resistencia conectada entre r1 y el ánodo del LED, y cátodo
conectado a GND).
17 ● un LED (amarillo, si es posible) para pin y1, con una resistencia en serie
como la de arriba.
18 ● un LED (verde, si es posible) para pin g1, con una resistencia en serie
como la de arriba.
19 ● Finalmente, instale otros 3 LED, como los de arriba, para r2, y2 y g2.
20 Ahora descargue el archivo de programa de su PC al kit de desarrollo y
verifique el funcionamiento del TLC. Juega con los interruptores para
probar todos los modos de operación. También puede aumentar la
frecuencia del reloj para acelerar la transición de rojo a amarillo, etc.

38. 21 Problema 8.6: Generador de señales n. ° 3
22 Resuelva el problema 8.2 sin utilizar el enfoque de máquina de estado finito.
23 Problema 8.7: Generador de señales n. ° 4
24 Resuelva el ejemplo 8.6 sin usar el enfoque FSM.
25 Para más trabajo es esta área, consulte los problemas 9.3, 9.4 y 9.6 del
capítulo 9.