Máquinas de Estados en la GAL22V10 Usando ABEL-HDL

Una Máquina de estados es un dispositivo digital que atraviesa una predeterminada secuencia de
estados. Las máquinas de estados se usan típicamente para control lógico secuencial. En cada
estado, el circuito almacena su historia pasada y usa tal historia para determinar qué hacer a
continuación.

Este documento ofrece una guía para ayudar al estudiante a formar diagramas de estado fáciles de
leer y mantener y ayudarle a evitar problemas. Las máquinas de estados a menudo tienen muchos
estados diferentes y transiciones complejas de estado que contribuyen a los problemas más
comunes, el cual es que demasiados términos producto son creados para el dispositivo electo. Los
tópicos discutidos en los siguientes párrafos aconsejan al estudiante cómo evitar este problema al
reducir el número de términos producto requeridos.
La página siguiente provee de consideraciones sobre Máquinas de estados:

• Usar identificadores en lugar de Números para los estados

• Registros de Estados de arranque
• Condiciones de Transición no satisfechas, usar Flip-Flops tipo D
• Condiciones de Transición no satisfechas, usar otros Flip-Flops
• Numerar Estados Adyacentes con un cambio de bit
• Usar salidas con Registros de Estado para Identificar Estados
• Usar Descripciones Simbólicas de Estado

Usar identificadores en lugar de Números para Estados

Una Máquina de estado tiene diferentes “estados” que describen las salidas y las transiciones de
la máquina en cualquier punto dado. Típicamente, cada estado está dado por un nombre, y la
Máquina de estados está descrita en términos de transiciones desde un estado hacia otro. En un
dispositivo real, tal Máquina de estados se implementa con registros que contienen suficientes
bits para asignar un único número a cada estado. Los estados son en realidad valores de bits en
los registros, y tales valores de bits se usan junto con otras señales para determinar las
transiciones de estado.
Mientras el estudiante desarrolla un diagrama de estados, él necesita etiquetar varios estados y las
transiciones de estados. Si él etiqueta los estados con identificadores que les han asignado valores
constantes, en vez de etiquetar los estados directamente con números, él puede fácilmente
cambiar las transiciones de estado o los valores de los registros asociados con cada estado.
Cuando el estudiante escribe un diagrama de estado, deberá primero describir la Máquina de
estados con nombres para los estados, y después asignar valores de bits a los registros de estado
a los nombres de los estados.

Para un ejemplo, ver la siguiente Figura para una Máquina de estado llamada “MaqEdos.” (Tal
Máquina de estados es también discutida en el ejemplo de diseño.) . En el ejemplo, los
identificadores (A, B, C y D) especifican los estados. A tales identificadores se les asigna un
valor constante decimal en la sección de declaraciones que identifican los valores de bit en el
registro de estado para cada estado. A, B, C y D son sólo identificadores: ellos no indican el
patrón de bits de la máquina de estados. Sus valores declarados definen el valor del registro de
estados (sreg) para cada estado. Los valores declarados son 0, 1, 3 y 2.

Prof. S. Saucedo 1 ICE/2007

 Figura 1. Diagrama de máquina de estados con cuatro estados.

Secuencia de cuatro estados

El siguiente diseño es un simple secuenciador que demuestra el uso de ABEL-HDL para definir
los diagramas de estado, con el software de desarrollo ispLEVER starter de Lattice. El número de
estados del Diagrama de Estados que puede ser procesado depende del número de transiciones y
la ruta de las transiciones. Por ejemplo, un contador de 64 estados usa menos términos (y
ecuaciones más pequeñas) que un contador de 63 estados. Para diseños de contadores grandes,
usar la sintaxis CuentaA:= CuentaA + 1 para crear un contador en lugar que usar una máquina de
estados. Ver también el ejemplo del contador universal para posterior información sobre
implementación de contadores.

Prof. S. Saucedo 2 ICE/2007

MODULE MaqEdos

TITLE 'Maquina de Estados'

q1,q0 pin 14,15 istype 'reg,invert';

" entradas
reloj,hab,start,hold,reset pin 1,11,4,2,3;
" salidas
parar pin 17 istype 'reg';
en_B,en_C,en_D pin 18,19,20;
" registros de estados
sreg = [q1,q0];
" Valores de estado...
A = 0; B = 1; C = 3; D = 2;
equations
[q1,q0,parar].clk = reloj;
[q1,q0,parar].oe = !hab;
state_diagram sreg;
State A: " Se mantiene en estado A hasta que start se active.
en_B = 0;
en_C = 0;
en_D = 0;
IF (start & !reset) THEN B WITH parar := 0;
ELSE A WITH parar := parar.fb;
State B: " Avanza al estado C a menos que reset este activo
en_B = 1; " o hold este activo. Enciende indicador de parar
en_C = 0; " si reset.
en_D = 0;
IF (reset) THEN A WITH parar := 1;
ELSE IF (hold) THEN B WITH parar := 0;
ELSE C WITH parar := 0;
State C: " Avanza al estado D a menos que reset este activo
en_B = 0; " el reset se impone al hold.
en_C = 1;
en_D = 0;
IF (reset) THEN A WITH parar := 1;
ELSE IF (hold) THEN C WITH parar := 0;
ELSE D WITH parar := 0;
State D: " Regresa a A al menos que hold este activo
en_B = 0; " el reset se impone al hold.
en_C = 0;
en_D = 1;
IF (hold & !reset) THEN D WITH parar := 0;
ELSE A WITH parar := 0;

Fig. 2 Listado para diseñar con ABEL-HDL la Máquina de Estados (parte inicial)

Prof. S. Saucedo 3 ICE/2007

" vectores de prueba editados...

test_vectors
([reloj,hab,start,reset,hold]->[sreg,parar,en_B,en_C,en_D])
[ .p. , 0 , 0 , 0 , 0 ] -> [ A , 0 , 0 , 0, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ A , 1 , 0 , 0 , 0];
[ .c. , 0 , 1 , 0 , 0 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ C , 0 , 0 , 1, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ D , 0 , 0 , 0, 1];
[ .c. , 0 , 1 , 0 , 0 ] -> [ A , 0 , 0 , 0, 0];
[ .c. , 0 , 1 , 0 , 0 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 0 , 0 , 1 , 0 ] -> [ A , 1 , 0 , 0, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ A , 1 , 0 , 0, 0];
[ .c. , 0 , 1 , 0 , 0 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 0 , 0 , 0 , 1 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 0 , 0 , 0 , 1 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ C , 0 , 0 , 1, 0];
[ .c. , 0 , 0 , 0 , 1 ] -> [ C , 0 , 0 , 1, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ D , 0 , 0 , 0, 1];
[ .c. , 0 , 0 , 0 , 1 ] -> [ D , 0 , 0 , 0, 1];
[ .c. , 0 , 0 , 0 , 0 ] -> [ A , 0 , 0 , 0, 0];
[ .c. , 0 , 0 , 0 , 0 ] -> [ A , 0 , 0 , 0, 0];
[ .c. , 0 , 1 , 0 , 0 ] -> [ B , 0 , 1 , 0, 0];
[ .c. , 1 , 0 , 0 , 0 ] -> [.z. , .Z., 0 , 1, 0];
[ .c. , 1 , 0 , 0 , 0 ] -> [.z. , .Z., 0 , 0, 1];

END
Fig. 2 Listado para diseñar con ABEL-HDL la Máquina de estados (parte final)

Especificación del diseño

La figura 1 muestra al diseño del secuenciador con un diagrama de estados que exhibe las
transiciones y las salidas deseadas. La máquina de estados arranca en el estado A y permanece en
tal estado hasta que la entrada 'start' se hace “1”. Entonces ella va desde el estado A hacia el
estado B, desde el estado B hacia el estado C, desde el estado C hacia el estado D y regresa al
estado A. Ella permanece en el estado A hasta que la entrada 'start' sea alta de nuevo. Si la
entrada 'reset' se hace “1”, la máquina de estados retorna al estado A en el siguiente ciclo de reloj.
Si este reset hacia el estado A ocurre durante el estado B (o el C), un salida 'parar' sincrónica se
hace “1”, y permanece alta hasta que la máquina es de nuevo arrancada
.
Durante los estados B, C y D, las salidas asíncronas 'en_B', ‘en_C’ y 'en_D' se hacen “1” para
indicar el estado actual correspondiente. Al activar la entrada 'hold', ella causará que la máquina
se detenga en un estado B, C o D. hasta que 'hold' no esté más en alto, o que 'reset' se haga “1”.

Método de diseño

El secuenciador se describe mediante el uso de la sección STATE_DIAGRAM en el archivo

fuente. La figura 2 ilustra el archivo fuente para el diseño secuencial. En tal archivo, el diseño
recibe un título, el dispositivo GAL22V10 es declarado antes, y las declaraciones de pines se
llevan al cabo. Las constantes se declaran para simplificar la notación del diagrama de estados.
Los dos registros de estado se agrupan en un conjunto llamado 'sreg' y cuatro estados (A, B, C y
D) son declarados, con valores apropiados especificados para cada uno de ellos. Finalmente,
cuando la entrada ‘hab’ se hace ‘1’, las tres salidas sincrónicas se van al tercer estado.

Prof. S. Saucedo 4 ICE/2007

Vectores de Prueba

Al final del archivo fuente se especifican alrededor de veinte vectores para probar el código
JEDEC grabado en la GAL22V10. Ver la figura 3.

Fig. 3. Formas de onda para los vectores de prueba.

Cablear la aplicación según el esquema siguiente:

+---------\ /---------+
| \ / |
| ----- |
reloj | 1 24 | Vcc
| |
hold | 2 23 |
| |
reset | 3 22 |
| |
start | 4 21 |
| |
| 5 20 | en_D
| |
| 6 19 | en_C
| |
| 7 18 | en_B
| |
| 8 17 | parar
| |
| 9 16 |
| |
| 10 15 | !q0
| |
hab | 11 14 | !q1
| |
GND | 12 13 |
| |
| |
`---------------------------'

Prof. S. Saucedo 5 ICE/2007