Diseño de CSS I PDF

Electrónica Digital II Diseño de Circuitos Secuénciales Sincrónicos
Profesor Víctor Escartín
DISEÑO DE CIRCUITOS SECUENCIALES SINCRÓNICOS
Objetivos:
- Análisis de circuitos secuénciales sincrónicos (CSS).
- Conocer un método de diseño de CSS.
- CSS realizados con PLD, programación con VHDL.
- Aplicaciones.
Sumario:
- Introducción.
- Análisis de CSS.
- Método manual de diseño de CSS
- Diseño de CSS con VHDL
- Ejemplos.
Bibliografía:
Monografia, Alberto Hernandez, capitulo 1, Introducción al diseño digital de circuitos lógicos secuenciales, 2002.
Digital Design Principles and Practices. John F. Wakerly, Second edition, Prentice Hall, 2000
Analisis, Capitulo: VII , paginas: 550 a 562
Diseño, Capitulo: VII , paginas: 563 a 604, 641 a 644, 747 a 787
Problemas. 7.30 a 7.32, 7.34, 7.36, 7.41, 7.42
1
DISEÑO DE CIRCUITOS SECUENCIALES SINCRÓNICOS
Introducción.
En el diseño de CSS se pueden emplear varios métodos, dependiendo del nivel de integración de las componentes que se utilicen.
Método de diseño de CSS empleando circuitos de bajo nivel de integración.

Los pasos para diseñar un circuito secuencial sincrónico empleando circuitos de bajo nivel de integración, partiendo de planteamiento
en palabra son:
1. Construir una tabla de estado/salida correspondiente a la descripción en palabras, utilizando nombres nemotécnicos para los
estados. También es posible partir de un diagrama de estado.
2. (opcional) Minimizar el número de estados en la tabla de estado/salida.
3. Seleccionar un conjunto de variables de estado y asignar combinaciones a las variables de estado.
4. Sustituir la combinación de las variables de estados en la tabla de estado / salida.
5. Seleccionar el tipo de flip-flop.
6. Construir la tabla de excitación.
7. Obtener las ecuaciones de excitación.
8. Obtener las ecuaciones de salida.
9. Dibujar el diagrama lógico.
En esta sección se describirá cada uno de estos pasos básicos para el diseño de una maquina secuencial sincrónica. El primer paso es el
más importante, ya que es en este, donde el diseñador realmente diseña. En el mismo se pasa por el creativo proceso de trasladar
desde una descripción en palabra de la máquina de estados hasta una descripción tabular de la misma. El segundo paso es algo difícil
aún para diseñadores experimentados, aunque el tercer paso también necesita de experiencia. Los siguientes pasos se realizan
siguiendo un proceso de diseño bien definido.
Diseño de la tabla de estado.

Diseñar la tabla de estado o su equivalente el diagrama de estado es un proceso creativo semejante a escribir un programa de
computación en varios aspectos como son:
Se comienza con una descripción precisa de las entradas y salidas, pero posiblemente con una descripción ambigua de las
relaciones entre ellas y usualmente sin una pista clara de como obtener la salida a partir de las entradas.
Durante el diseño usted tiene que identificar y seleccionar entre diferentes modos de hacer las cosas. En algunos casos
utilizando sentido común y en otros arbitrariamente.
Hay que identificar y manejar casos especiales que no fueron incluidos en la descripción original.
Probablemente hay que mantener varias ideas en la mente durante el proceso de diseño.
Como el proceso de diseño no es un algoritmo, no hay garantía que se pueda completar la tabla de estado o programa
utilizando un número finito de estados o líneas de código. Sin embargo se debe tratar de hacerlo.
Cuando finalmente se corra la máquina de estado o programa, esta debe hacer exactamente lo que se necesita que haga.
No hay garantía de la máquina corra la primera vez, por lo que tendrá que ponerla a punto en forma iterativa.
Se presentara el diseño de la tabla de estados a través de un ejemplo:

Ejemplo # 1.
Diseñar un circuito secuencial sincrónico con dos entradas, A y B y una sola salida Z. La salida debe ser 1 si A mantuvo el mismo
valor durante los dos periodos de reloj anteriores o si B ha sido 1 desde que la primera condición fue verdadera. En cualquier otro caso
la salida debe ser 0.
De la descripción en palabra conocemos que es una máquina tipo Moore, ya que las salidas dependen solo del estado actual o sea de
lo que pasa en los periodos de reloj anteriores. En la figura 1, se prepara una columna para cada uno de los posibles estados futuros y
una simple columna para la salida.
Figura 1. Tabla de estado primer paso.

Observación Estado actual Estado futuro
AB
00 01 11 10 Z
Estado inicial INIT 0
2
El orden en que se ponga las combinaciones de las entradas no tiene importancia en esta parte del diseño pero se escribe en el mismo
orden que en los mapas de Karnaugh para facilitar posteriormente la obtención de las ecuaciones de excitación.
En una máquina Mealy se omite la columna de la salida y se escribe el valor de la salida para cada combinación de las variables de
entrada. La primera columna es simplemente una observación sobre el significado de cada estado o la historia asociada con él.
La descripción en palabra no es específica acerca de lo que pasa cuando esta máquina es inicializada por lo que hay que improvisar.
Supondremos que cuando el equipo se enciende la máquina entra en un estado inicial, identificado como INIT en este ejemplo. Se
escribe el nombre del estado inicial (INIT) en la primera fila y se deja el espacio suficiente para completar el diseño. También se llena
en la columna de la salida el valor correspondiente al estado INIT, por sentido común este debe ser 0 ya que no hay historia anterior a
este estado. Ahora hay que escribir en los estados futuros a partir del estado INIT. La salida Z no puede ser 1 hasta que se observe
durante dos periodos de reloj la entrada A, por lo que crearemos dos estados A0 y A1. Estos recordaran los valores de A en los relojes
anteriores ver figura 2. En estos dos estados la salida es cero ya que no se ha satisfecho la primera condición para que la salida sea 1.
Figura 2. Tabla de estado segundo paso.

AB
00 01 11 10 Z
Estado inicial Init A0 A0 A1 A1 0
Cero a A A0 0
Uno en A A1 0
El significado preciso del estado A0 es que se obtuvo un cero en A en el reloj anterior además como Z = 0 esto implica que en él reloj
anterior a este A fue igual a uno, porque sino Z debería ser 1, además B = 0 desde que un par de relojes antes con dos A iguales.
El significado para el caso de A1, es que en el reloj anterior a este A = 0, y B = 0, para garantizar Z = 0.
En este momento ya sabemos que esta máquina tiene al menos tres estados.
Para seguir es mejor ir recorriendo el camino para lograr que la salida se active. Por lo que en el estado A0, si de nuevo A0 es cero
entonces iremos a un nuevo estado con la salida en 1 y que denominaremos OK según se muestra en la figura 3.
Figura 3. Tabla de estado tercer paso.

AB
00 01 11 10 Z
Estado inicial INIT A0 A0 A1 A1 0
Cero a A A0 OK OK A1 A1 0
Uno en A A1 A0 A0 OK OK 0
Dos iguales en A OK 1
En el estado inicial si A = 1 no podemos tener dos entradas iguales en una fila, por lo que vamos al estado A1 para recordar que hemos
recibido un 1. En forma similar ocurrirá con OK, ver figura 4.
Figura 4. Tabla de estado cuarto paso.

AB
00 01 11 10 Z
Estado inicial INIT A0 A0 A1 A1 0
Dos iguales en A OK 1
Si estamos en el estado OK, la descripción en palabras nos dice que debemos permanecer en este estado mientras que B = 1
independiente de A. Si B = 0 hay que volver a esperar por dos 0 o dos 1 en la entrada A. En este caso ocurre un pequeño problema. La
entrada A actual puede ser el segundo valor igual o no, por lo que en caso afirmativo habría que seguir en el estado OK o volver a A0
o A1.
3
Figura 5. Tabla de estado quinto paso.

AB
00 01 11 10 Z
Dos iguales en A OK ¿? OK OK ¿? 1
Hasta aquí hemos definido el estado OK no muy precisamente, este estado no recuerda lo suficiente como para decirnos que camino
seguir. este problema se puede resolver según se muestra en la figura 6. En la cual se ha separado el estado OK en dos estados
identificados como OK00 y OK11 que recuerdan el valor de la entrada A. Los siguientes estados se pueden seleccionar de los ya
existentes, como se muestra en la figura 7. Por ejemplo si en OK00, A = 0 debemos permanecer en OK00, no hay que crear un nuevo
estado que recuerde que han ocurrido tres ceros seguidos en A, ya que la máquina no necesita recordar este caso. De este modo
cerramos la tabla de estado con un número finito de estados.
Figura 6. Tabla de estado sexto paso.

AB
00 01 11 10 Z
Cero a A A0 OK00 OK00 A1 A1 0
Uno en A A1 A0 A0 OK11 OK11 0
Dos ceros en A OK00 1
Dos unos en A OK11 1
Figura 7. Tabla de estado séptimo paso.

AB
00 01 11 10 Z
Dos ceros en A OK00 OK00 OK00 OK11 A1 1
Dos unos en A OK11 A0 OK00 OK11 OK11 1
Minimización de estados
La figura 7 es una tabla de estado mínima para nuestra descripción en palabras ya que contiene el menor número posible de estados.
En la figura 8 se muestra una tabla de estados con más estados que los necesarios. Existe un procedimiento para minimizar el número
de estados en estos casos. La idea básica es identificar estados equivalentes. Estos no dependen solo de tener la salida igual sino
también del valor de las variables de estado internas. Dos estados equivalentes pueden sustituirse por uno solo.
Dos estados son equivalentes si se cumplen dos condiciones:
-Deben producir la misma salida, en una máquina Mealy esto debe ser cierto para todas las combinaciones de las variables de entrada.
-Para cada combinación en las entradas deben tener el mismo estado futuro.
En el ejemplo de la figura 8 los estados OK00 y OKA0 son equivalentes porque producen la misma salida y tienen los mismos estados
futuros. En forma similar puede plantearse que OK11 y OKA1 también son equivalentes y pueden sustituirse por uno de los dos.
4
Figura 8. Tabla de estado no mínima.

AB
00 01 11 10 Z
Dos ceros en A OK00 OK00 OK00 OKA1 A1 1
Dos unos en A OK11 A0 OKA0 OK11 OK11 1
OK un cero en A OKA0 OK00 OK00 OKA1 A1 1
OK un uno en A OKA1 A0 OKA0 OK11 OK11 1
Los procedimientos de simplificación son raramente utilizados por los diseñadores. Con un cuidadoso diseño para problemas no muy
complejos se pueden lograr tablas de estados mínimas o casi mínimas sin tener que utilizar procedimientos de simplificación. Además
hay casos en que incrementar el número de estados puede simplificar el diseño. En general es más importante tratar de simplificar
durante la etapa de asignación de estados.
Asignación de estados.
El siguiente paso es determinar cuantas variables binarias son requeridas para representar los estados de la tabla de estados y asignar
una combinación específica a cada estado. Llamaremos a la combinación binaria asignada a un estado particular un estado codificado.
El número total de estados en una máquina con N flip- flops es 2N, por lo que el número de flip-flops necesarios para codificar S
estados es log2[s].
El ejemplo que hemos venido analizando cuya tabla de estado/salida fue mostrada en la figura 7, tiene 5 estados por lo que requiere 3
flip-flops. Desde luego que 3 flip-flops producen hasta 8 estados, por lo que en este caso tendremos 8 - 5 = 3 sin utilizar.
El total de opciones que tenemos para seleccionar M códigos de un total de N esta dado por los coeficientes binomiales lo que se
representa por [NM] y se calcula en base a:
N!
En nuestro ejemplo hay [85] modos diferentes de seleccionar 5 códigos de 8 estados posibles y 5! modos de
( M !*(N − M )!)
asignar los 5 nombres a cada selección. Es decir hay:
[(8!)/(5!*3!)]*5! = 6720 modos diferentes de asignar los 5 estados de nuestro ejemplo a las combinaciones de tres variables binarias.
Lo que resulta imposible de analizar.
La asignación más simple resulta en utilizar la numeración binaria en su orden. Sin embargo este orden no siempre da el circuito más
simple y por lo tanto el más económico.
¿Como seleccionar la mejor asignación de estados para un problema dado? En general la única forma de encontrar la mejor
asignación es probar todas las variantes posibles. Lo que es prácticamente imposible, por lo que hay que acudir a la experiencia y a
algunas reglas practicas para lograr una asignación de estados razonable:
-Seleccionar un código para el estado inicial en el cual la máquina pueda ser fácilmente forzada al ser reseteada (00 o 11).
-Minimizar el número de variables de estados que cambian en una transición.
-Maximizar el número de variables de estados que no cambian en un grupo de estados relacionados, es decir un grupo de estados en
los cuales la mayoría de las transiciones esten en ese grupo.
-Explotar las simetrías que presente el problema en particular con las correspondientes simetrías en la tabla de estados. Supongamos
por ejemplo que un estado o un grupo de estados significan casi la misma cosa. una vez que la asignación ha sido realizada para el
primero, una asignación similar que se diferencie en solo un bit debe utilizarse para el segundo.
-Si hay estados sin utilizarse, utilizar lo mejor de los estados disponibles para lograr los resultados deseados. O sea no limitar a los
primeros números binarios.
-Descomponer el conjunto de variables de estados en bits o campos individuales donde cada bit o campo tiene un significado definido
con respecto al efecto de las entradas o al comportamiento de las salidas.
-Considerar el utilizar más del mínimo número de variables de estado para lograr un mejor resultado.
Algunas de estas ideas estan incorporada en las asignaciones de estados presentes en la figura 9.
En la columna encabezada por descompuesto el estado inicial es el 000 que es fácilmente realizable con el terminal de reset de los
biestables. Esta asignación aprovecha en que solo hay 4 estados además del inicial en el cual no se vuelve a entrar. Por lo tanto Q1 = 0,
5
puede utilizarse para indicar que se esta en el estado INIT. Q2 y Q3 pueden utilizarse para la selección de los otros 4 estados posibles.
En la figura 9 los otros 4 estados aparecen con la asignación correspondiente con el conteo binario, pero esto es una casualidad. Q2 y
Q3 tienen significado relacionado con las entradas y salidas. Q3 señala el valor anterior de A y Q2 que la condición de que la salida es
1 fue satisfecha en el estado actual.
Descomponiendo el significado de los bits que identifican a los estados como hemos hecho en este ejemplo esperamos que la lógica
que se requiera para el próximo estado y la salida sea más simple que una asignación arbitraria.
La asignación identificada como one-hot, también da resultados satisfactorios. Utiliza más del mínimo número de variables de estados,
utiliza un bit por estado. Presenta la ventaja de que usualmente requiere de ecuaciones de excitación muy simples ya que cada flip-flop
solo tiene que ir a 1 en un solo estado. Una desventaja es que si hay muchos estados se necesitan muchos flip- flops. Es ideal para
máquinas con S estados que requieran de un 1 para indicar su estado y por lo tanto no necesitan de circuitos.
La última columna de la figura 9 utiliza una combinación "no-hot" para su estado inicial la cual es más facil de lograr en general y en
caso de que este estado no se vuelva a necesitar esto no tiene implicaciones.
Hay dos recomendaciones para el caso que existan estados sin utilizar:
-Mínimo riesgo. (Minimal risk)
Esta aproximación considera que es posible que la máquina pueda caer en uno de los estados no utilizados (quizás por un
fallo del hardware, por una entrada no esperada o por un error en el diseño), por lo que se debe prever que de estos estados
avance al estado inicial o a un estado "seguro". Esto puede ser una consecuencia automática de alguna metodología de
diseño, si el estado inicial es codificado por 00.
-Mínimo costo. (Minimal cost).
En este caso se considera que la máquina nunca entra en un estado no utilizado. Por lo que en las tablas de transición y de
excitación los estados siguientes a los no utilizadas se identifican como "don't-cares".
Figura 9 Ejemplos de posibles asignaciones de estados.

Q1 – Q3 Q1 – Q3 Q1 – Q3 Q1 – Q5 Q1 – Q4
Simple Gray Descompuesto One-hot Almost one-hot
Secuencial One-hot-one One-hot-zero
Estado
INIT 000 000 000 00001 0000
A0 001 001 100 00010 0001
A1 010 011 101 00100 0010
OK00 011 010 110 01000 0100
OK11 100 110 111 10000 1000
Síntesis utilizando flip-flops tipo D.

Una vez asignado un código a los estados, el resto del proceso de diseño es más o menos mecánico.
Se sustituye en la tabla de estados los nombres de los estados por sus códigos y esto da lugar a una tabla de transición. En esta se
muestra el código del próximo estado para cada estado presente y cada combinación en las variables de entrada. En la figura 10 se
muestra la tabla de transición para el ejemplo que hemos estado analizando utilizando la asignación identificada como descompuesta.
Figura 10. Tabla de transición y de salida.

Estado
Estado futuro
Presente
AB
Q1 Q2 Q3 00 01 11 10 Z
000 100 100 101 101 0
100 110 110 101 101 0
101 100 100 111 111 0
110 110 110 111 101 1
111 100 110 111 111 1
El próximo paso es escribir la tabla de excitación, que muestra para cada estado codificado y cada entrada del sistema la excitación
que se requiere en cada entrada de los flip-flops a utilizar para que avancen al estado siguiente. Esta claro esta depende del tipo de
flip-flop que se utilice.
En este ejemplo utilizaremos flip-flop tipo D, cuya ecuación característica es Q* = D y cuya tabla de excitación se muestra en la figura
11.
6
Figura 11, Tabla de excitación del Flip - Flop D
QN QN+1 D
0 0 0
0 1 1
1 0 0
1 1 1
Dada la ecuación característica del Flip-Flop D y que tiene una sola entrada la tabla de excitación y la de transición son iguales
excepto en que en esta última lo que se representan son las entradas D y en la otra son las salidas Q, que en este caso coinciden. En
base a lo anterior podemos plantear que para el flip-flop tipo D no hay que escribir la tabla de excitación sino una sola que podemos
identificar como tabla de transición/excitación. La tabla de excitación es semejante a una tabla de verdad para tres funciones lógicas
combinacionales (D1, D2, D3) de 5 variables (A, B, Q1, Q2, Q3).
A continuación en la figura 12, se muestran los mapas de Karnaugh para el ejemplo anterior considerando que de los estados no
utilizados se obligue al estado inicial (mínimo riesgo).
En la figura 13, se muestra los mapas para el caso que se consideren los estados no utilizados como don't-care (mínimo costo).
Figura 12 Mapas de Karnaugh del ejemplo, considerando que todos los estados opcionales fuerzan al estado inicial.
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 1 1 1 1 00 1 1 1 1
01 0 0 0 0 01 1 1 1 1
11 0 0 0 0 11 1 1 1 1
10 0 0 0 0 10 1 1 1 1
D1 = Q1 +/Q2 /Q3
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 0 0 0 0 00 1 1 0 0
01 0 0 0 0 01 0 0 1 1
11 0 0 0 0 11 0 1 1 1
10 0 0 0 0 10 1 1 1 0
D2 = Q1 /Q3 /A + Q1 Q3 A + Q1 Q2 B
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 0 0 1 1 00 0 0 1 1
01 0 0 0 0 01 0 0 1 1
11 0 0 0 0 11 0 0 1 1
10 0 0 0 0 10 0 0 1 1
D3 = Q1 A + Q2' Q3' A
7
Figura 13. Mapas der Karnaugh del ejemplo, considerando que todo los estados opcionales sean don't-care.
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 1 1 1 1 00 1 1 1 1
01 x x x x 01 1 1 1 1
11 x x x x 11 1 1 1 1
10 x x x x 10 1 1 1 1
D1 = 1
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 0 0 0 0 00 1 1 0 0
01 x x x x 01 0 0 1 1
11 x x x x 11 0 1 1 1
10 x x x x 10 1 1 1 0
D2 = Q1 /Q3 /A + Q3 A + Q2 B
Q1 = 0 Q1 = 1
AB AB
Q2 Q3 00 01 11 10 Q2 Q3 00 01 11 10
00 0 0 1 1 00 0 0 1 1
01 x x x x 01 0 0 1 1
11 x x x x 11 0 0 1 1
10 x x x x 10 0 0 1 1
D3 = A
La salida se obtiene también mediante un mapa de Karnaugh cuyo resultado es:
Z = Q1 Q2 (mínimo riesgo)
Z = Q2 (mínimo costo)
El último paso es realizar el dibujo del circuito.
Ejemplo # 2.
Diseñar un circuito secuencial sincrónico con dos entradas X, Y y una sola salida Z. La salida debe ser 1, si el número de unos en las
entradas X y Y desde que la máquina comenzó es múltiplo de 4 y la salida es cero en los otros casos.
Paso No 1. Tabla de estado, ver la figura 14
Figura 14. Tabla de estado.
Estado
Estado futuro (S*)
Presente
XY
Observación S 00 01 11 10 Z
Solo ceros S0 S0 S1 S2 S1 1
Primer 1 S1 S1 S2 S3 S2 0
Segundo 1 S2 S2 S3 S0 S3 0
Tercer 1 S3 S3 S0 S1 S0 0
8
La asignación es la misma que la utilizada en los mapas de Karnaugh por dos razones:
-Se minimiza el número de cambio entre transiciones.
-Simplifica la realización de la tabla de excitación
En la figura 15 se muestra la tabla de transición / salida.
Figura 15. Tabla de transición / salida.

Estado
Estado futuro (S*)
Presente
S XY
Q2 Q1 00 01 11 10 Z
00 00 01 11 01 1
01 01 11 10 11 0
11 11 10 00 10 0
10 10 00 01 00 0
Tabla de excitación del Flip - Flop D

QN QN+1 D
0 0 0
0 1 1
1 0 0
1 1 1
XY XY
Q2 Q1 00 01 11 10 Q2 Q1 00 01 11 10
00 0 1 1 1 00 0 0 1 0
01 1 1 0 1 01 0 1 1 1
11 1 0 0 0 11 1 1 0 1
10 0 0 1 0 10 1 0 0 0
D1 D2
D1 = Q1 /X /Y + /Q2 /X Y + /Q1 X Y + /Q2 X /Y
D2 = Q2 /X /Y + Q1 /X Y + /Q2 X Y + Q1 X /Y
Z = /Q2 /Q1
Realicemos el ejemplo anterior pero empleando biestables JK.

Tabla de excitación.
QN Q N+1 J K
0 0 0 X
0 1 1 0
1 0 0 1
1 1 X 0
9
J K
XY XY
Q2 Q1 00 01 11 10 Q2 Q1 00 01 11 10
00 0 1 1 1 00 x 0 0 0
01 x x 0 x 01 0 0 1 0
11 x 0 0 0 11 0 1 1 1
10 0 0 1 0 10 x x 0 x
J1 = /Q2 /Q1 Y + /Q2 /Q1 X + /Q1 X Y K1 = Q2 Q1 Y + Q2 Q1 X + Q1 X Y
J K
XY XY
Q2 Q1 00 01 11 10 Q2 Q1 00 01 11 10
00 0 0 1 0 00 x x 0 x
01 0 1 1 1 01 x 0 0 0
11 x x 0 x 11 0 0 1 0
10 x 0 0 0 10 0 1 1 1
J2 = /Q2 Q1 Y + /Q2 Q1 X + /Q2 X Y K2 = Q2 /Q1 Y + Q2 /Q1 X + Q2 X Y
Ejemplo # 3
Diseñar una cerradura combinacional, que se abre para una cierta secuencia binaria. Esta máquina secuencial sincrónica tiene una
entrada X y dos salidas UNLK y HINT. La salida UNLK debe ser 1 si y solo si X = 0 y la secuencia de entradas recibida en los 7
relojes anteriores fue 0110111. La salida HINT debe ser 1 solo si el valor actual de X es el correcto en la secuencia.
Esta es una máquina Mealy para las dos salidas ya que las dos dependen de la historia anterior y del valor actual en X.
En la figura 16 se muestra la tabla de estados.
Figura 16, Tabla de estados / salidas.

Observación S X
0 1
Cerrado A B,01 A,00
Primer valor B B,00 C,01
Segundo C C,00 D,01
Tercero D E,01 A,00
Cuarto E B,00 F,01
Quinto F B,00 G,01
Sexto G E,00 H,01
Séptimo H B,11 A,00
S*, UNLK HINT
En A se considera que no se ha recibido ningún bit de la secuencia correcta. Son 8 estados por lo que se necesitan 3 flip- flops y no
sobran estados en este caso se utilizará la asignación más simple o sea el conteo binario. En la figura 17 se presenta la tabla de estado /
salida.
10
Figura 17, Tabla de transición / salida.
Q3 Q2 Q1 X
0 1
000 001,01 000,00
001 001,00 010,01
010 001,00 011,01
011 100,01 000,00
100 001,00 101,01
101 001,00 110,01
110 100,00 111,01
111 001,11 000,00
Q3*, Q2*, Q1*, UNLK, HINT
X Q3 X Q3
Q2 Q1 00 01 11 10 Q2 Q1 00 01 11 10
00 1 1 1 0 00 0 0 0 0
01 1 1 0 0 01 0 0 1 1
11 0 1 0 0 11 0 0 0 0
10 1 0 1 1 10 0 0 1 1
D1 = /Q2 /X + /Q2 /Q1 Q3 + Q2 /Q1 X + Q1 X Q3 + /Q1 /X /Q3 D2 = /Q2 Q1 X + Q2 /Q1 X
X Q3 X Q3
Q2 Q1 00 01 11 10 Q2 Q1 00 01 11 10
00 0 0 1 0 00 1 1
01 0 0 1 0 01 1 1
11 1 0 0 0 11 1 1
10 0 1 1 0 10 1 1
D3 = Q2 Q1 /X /Q3 + Q2 X Q3 + Q2 /Q1 Q3 HINT = /Q2 /Q1 /X /Q3 + Q2 Q1 /X + Q2 /Q1 X + /Q2 Q1 X + /Q2 X Q3
UNLK = Q1 Q2 Q3 /X
El diseño de un CSS tipo Moore puede realizarse de varias formas.

Salidas combinacionales codificadas a partir de los bits de estados. Es la variante mas utilizada cuando se utilizan CI de
bajo nivel de integración, porque minimiza la cantidad de Flip Flops que se requieren. Este diseño puede presentar
glitches en la salida y es relativamente lenta por el uso de circuitos para decodificar..
Salidas combinacionales que utilizan la codificación del uno caliente (one hot). Consiste en codificar los diferentes
estados de forma tal que en cada estado solo habrá un flip flop en uno y el resto en cero. Esto simplifica la lógica
combinacional aunque utiliza muchos flip flops, uno por cada estado. Permite obtener maquinas que trabajan a altas
frecuencias (100 MHz)
Salidas registradas codificadas a partir de los bits de estados. En este caso es necesario realizar la codificación
garantizando que exista en un bit del código el valor de uno solamente en los estados en donde la salida es uno, en los
demás estados ese bit tiene que ser cero.
Salidas registradas decodificadas a partir de los bits de estados. En este caso se necesita escribir la tabla de estado /
excitación de la salida en lugar de la tabla de estado / salida.
11
Método de diseño de CSS, empleando PLD.

Se comienza escribiendo la tabla de estados / salidas y a partir de aquí se utilizan las herramientas CAD como el VHDL. Para esto
vamos a introducir algunas sentencias nuevas.
Nuevas sentencias del VHDL.

PROCESS, es una sentencia concurrente que define su comportamiento a través de sentencias secuénciales.
PROCESS (CLK)
BEGIN
Sentencias secuénciales.
END PROCESS;
Sentencia IF. Se utiliza para escoger en función de alguna condición que sentencias deben ejecutarse.
IF condición # 1 THEN sentencia_secuencial;
ELSIF condición # 2 THEN sentencia_secuencial;
ELSE sentencia_secuencial;
END IF;
Enumeration TYPES (Tipos Enumerados). Es una lista del conjunto de todos los posibles valores que un objeto de ese
tipo puede tener. Se llama tipo enumerado porue en la lista se enumeran todos y cada uno de los valores que forman el
tipo. Se suele utilizar para decir los estados en una maquina de estados. Ejemplo:
TYPE STATES IS ( Reposo, Espera, Dato, Nodef,Error);

Una SIGNAL puede entonces ser declarada del typo enumeration, por ejemplo:
SIGNAL Current_State: STATES;
CASE-WHEN
Se utiliza para escoger que grupo de sentencias deben ejecutarse entre un conjunto de posibilidades, basándose en el rango
de valores de una determinada expresión de selección.
CASE Selection_Signal IS
WHEN value_1_of_Selection_Signal => (do something)
WHEN value_2_of_Selection_Signal => (do something)
WHEN last_value_of_Selection_Signal => (do something)
END CASE;
ATTRIBUTE STATE_ENCODING OF ESTADOS TYPE IS one_hot_zero;

Este atributo tiene las siguientes posibilidades:
one_hot_zero
one_hot_one
sequential
gray
State encoding (one-hot zero-state) for 'estado' is:

a := "0000000"; -- comienza con 0
b := "1000000";
c := "0100000";
d := "0010000";
e := "0001000";
f := "0000100";
g := "0000010";
h := "0000001";
State encoding (one-hot one-state) for 'estado' is:

a := "10000000"; -- comienza con 1
b := "01000000";
c := "00100000";
12
d := "00010000";
e := "00001000";
f := "00000100";
g := "00000010";
h := "00000001";
State encoding (sequential) for 'estado' is:

a := b"000";
b := b"001";
c := b"010";
d := b"011";
e := b"100";
f := b"101";
g := b"110";
h := b"111";
State encoding (gray) for 'estado' is:

a := "000";
b := "001";
c := "011";
d := "010";
e := "110";
f := "111";
g := "101";
h := "100";
Descripción de CSS o FSM.

Existen varios estilos de descripción VHDL de FSMs. Cada uno de ellos será el mas apropiado dependiendo de la
herramienta y el tipo de maquina que se quiera describir. Los resultados del diseño en cada caso son diferentes. Los
estilos descriptivos para FSM se pueden agrupar en explícitos e implícitos. En el estilo explícito la FSM se describe
utilizando un proceso combinacional para describir la función del próximo estado y un proceso secuencial para describir
las asignaciones sobre el registro de estados en la transición activa de la señal del reloj. Este estilo identifica claramente la
parte combinacional de los elementos de memoria. Veamos un ejemplo.
13
Ejemplo 4
Diseñar la maquina definida por el diagrama de estado mostrado en la siguiente figura.
/X, /Z X, Z
S0 S1
X, /Z
X, Z
X, /Z
/X, /Z
S2 S3
X, /Z
/X, Z
LIBRARY IEEE;
USE IEEE.Std_Logic_1164.ALL;
ENTITY EJ_4 IS PORT(

X,Reset,CLK : IN Std_Logic;
Z: OUT Std_Logic);
END EJ_4;
ARCHITECTURE EJ_4 OF EJ_4 IS

TYPE Estados IS (S0, S1, S2, S3);
SIGNAL Estado, Nxt_Estado: Estados;
BEGIN
PROCESS (Estado,X)
BEGIN
-- set up default values
Nxt_Estado <= Estado;
CASE Estado IS
WHEN S0 => Z <= '0';
IF X = '0' THEN Nxt_Estado <= S1;
ELSE Nxt_Estado <= S2;
END IF;
WHEN S1 => Z <= X;
Nxt_Estado <= S0;
WHEN S2 => Z <= '0';
ELSE Nxt_Estado <= S3;
END IF;
WHEN S3 => Z <= '1';
END IF;
END CASE;
END process;
PROCESS (Reset,CLK)
14
BEGIN
IF Reset='0' THEN Estado <= S0;
ELSIF CLK' Event AND CLK = '1' THEN Estado <= Nxt_Estado;
END IF;
END process;
END;
State encoding (sequential) for 'nxt_estado' is:

s0 := b"00";
s1 := b"01";
s2 := b"10";
s3 := b"11";
State variable 'estado' is represented by a Bit_vector (0 to 1).
s0 := b"00";
s1 := b"01";
s2 := b"10";
s3 := b"11";
DESIGN EQUATIONS (08:42:36)
z= estadoSBV_0.Q * estadoSBV_1.Q
+ x * estadoSBV_1.Q
estadoSBV_0.D = /x * estadoSBV_0.Q * estadoSBV_1.Q

+ x * /estadoSBV_1.Q
estadoSBV_0.AR = /reset
estadoSBV_0.SP = GND
estadoSBV_0.C = clk
estadoSBV_1.D = /x * /estadoSBV_1.Q
+ estadoSBV_0.Q
estadoSBV_1.C = clk
15
Ejemplo 5.
Veamos otro ejemplo del estilo explicito, que es una variante del problema anterior utilizando la misma tabla de estado
anterior.
LIBRARY IEEE;
USE IEEE.Std_Logic_1164.ALL;
ENTITY EJ_5 IS PORT(

X,Reset,CLK : IN Std_Logic;
Z: OUT Std_Logic);
END EJ_5;
ARCHITECTURE EJ_5 OF EJ_5 IS

TYPE Estados IS (S0, S1, S2, S3);
SIGNAL Estado: Estados:=S0;
BEGIN
PROCESS (Reset, CLK, Estado,X)
BEGIN
IF Reset='0' THEN Estado <= S0;
ELSIF Rising_Edge(CLK) THEN
CASE Estado IS
WHEN S0 => IF X = '0' THEN Estado <= S1;
ELSE Estado <= S2;
END IF;
WHEN S1 => Estado <= S0;
ELSE Estado <= S3;
END IF;
END IF;
END CASE;
END IF;
CASE Estado IS
WHEN S0 => Z <= '0';
WHEN S1 => Z <= X;
WHEN S2 => Z <= '0';
WHEN S3 => Z <= '1';
END CASE;
END process;
END;

s0 := b"00";
s1 := b"01";
s2 := b"10";
s3 := b"11";
DESIGN EQUATIONS
z= estadoSBV_0.Q * estadoSBV_1.Q
+ x * estadoSBV_1.Q

16
estadoSBV_0.C = clk
estadoSBV_1.D = /x * /estadoSBV_1.Q
+ estadoSBV_0.Q
estadoSBV_1.C = clk
Ejemplo # 6
Diseñe una maquina de estado sincrónica tipo MOORE con una entrada X y una salida W, tal que W = 1 cuando ocurra una
cualquiera de las secuencias 10101 ó 10110 en la variable de entrada. En cualquier otro caso W = 0. Se admite superposición de
secuencias.
A partir del enunciado se obtiene la tabla de estados / salidas.
EP X W
0 1
A A B 0
B C B 0
C A D 0
D E F 0
E A G 0
F H B 0
G E F 1
H A D 1
Estado Descripción Significado

A Estado inicial, en el no hay ningún bit de secuencia. Nada
B Tenemos el primer bit de secuencia 1
C Tenemos los dos primeros bits de la secuencia 10
D Tenemos los tres primeros bits de la secuencia 101
E Tenemos los cuatros primeros bits de una secuencia 1010
F Tenemos los cuatros primeros bits de la otra secuencia 1011
G Tenemos completa una secuencia 10101
H Tenemos completa la otra secuencia 10110
De la tabla de estados / salida podemos escribir el programa en VHDL.
-- Fecha de creación: 26/02/03

-- Proyecto: CSS_1
-- EJ_4
-- 16V8
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY EJ4 IS
PORT (X, CLK: IN Std_logic;
W: OUT Std_Logic);
17
END EJ4;
ARCHITECTURE A_EJ4 OF EJ4 IS

TYPE ESTADOS IS (A,B,C,D,E,F,G,H);
SIGNAL Estado: ESTADOS;
BEGIN
PROCESS (CLK)
BEGIN
IF (CLK'Event AND CLK = '1') THEN
CASE estado IS
WHEN A => IF X = '1' THEN estado <= B;
ELSE estado <= A;
END IF;
WHEN B => IF X = '1' THEN estado <= B;
ELSE estado <= C;
END IF;
WHEN C => IF X = '1' THEN estado <= D;
ELSE estado <= A;
END IF;
WHEN D => IF X = '1' THEN estado <= F;
ELSE estado <= E;
END IF;
WHEN E => IF X = '1' THEN estado <= G;
ELSE estado <= A;
END IF;
WHEN F => IF X = '1' THEN estado <= B;
ELSE estado <= H;
END IF;
WHEN G => IF X = '1' THEN estado <= F;
ELSE estado <= E;
END IF;
WHEN H => IF X = '1' THEN estado <= D;
ELSE estado <= A;
END IF;
WHEN OTHERS => estado <= A;
END CASE;
END IF;
END Process;
-- salida combinacional
W <= '1' WHEN (estado = G) OR (estado = H) ELSE '0';
END;

a := b"000";
b := b"001";
c := b"010";
d := b"011";
e := b"100";
f := b"101";
g := b"110";
h := b"111";
DESIGN EQUATIONS
w= estadoSBV_0.Q * estadoSBV_1.Q
estadoSBV_0.D = estadoSBV_0.Q * /estadoSBV_1.Q * /x * estadoSBV_2.Q

18
+ /estadoSBV_0.Q * estadoSBV_1.Q * estadoSBV_2.Q
+ estadoSBV_0.Q * x * /estadoSBV_2.Q
+ estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q
estadoSBV_0.C = clk
estadoSBV_1.D = /estadoSBV_0.Q * estadoSBV_1.Q * x * /estadoSBV_2.Q

+ estadoSBV_0.Q * /estadoSBV_1.Q * x * /estadoSBV_2.Q
+ estadoSBV_0.Q * estadoSBV_1.Q * x * estadoSBV_2.Q
+ /estadoSBV_1.Q * /x * estadoSBV_2.Q
estadoSBV_1.C = clk
estadoSBV_2.D = estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q

+ estadoSBV_1.Q * x
+ /estadoSBV_0.Q * x
estadoSBV_2.C = clk
Ejemplo # 7
Igual al ejemplo #4, pero añadiéndole:
ATTRIBUTE STATE_ENCODING OF ESTADOS TYPE IS one_hot_zero;

-- Proyecto: CSS_1
-- EJ_5
-- 16V8
LIBRARY IEEE;
ENTITY EJ5 IS
W: OUT Std_Logic);
END EJ5;

ATTRIBUTE state_encoding OF Estados: TYPE IS one_hot_zero;
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= E;
END IF;
19
ELSE estado <= A;
END IF;
ELSE estado <= H;
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
END CASE;
END IF;
END Process;
END;
State encoding (one-hot zero-state) for 'estado' is:

a := "0000000";
b := "1000000";
c := "0100000";
d := "0010000";
e := "0001000";
f := "0000100";
g := "0000010";
h := "0000001";
DESIGN EQUATIONS
estadoSBV_1.D = /x * estadoSBV_0.Q
estadoSBV_1.C = clk
estadoSBV_5.D = x * estadoSBV_3.Q
estadoSBV_5.C = clk
estadoSBV_6.C = clk
/w = /estadoSBV_5.Q * /estadoSBV_6.Q
estadoSBV_0.D = /estadoSBV_5.Q * /estadoSBV_6.Q * x * /estadoSBV_1.Q * /estadoSBV_2.Q * /estadoSBV_3.Q

+ x * estadoSBV_4.Q
+ x * estadoSBV_0.Q
estadoSBV_0.C = clk
+ estadoSBV_5.Q * x
estadoSBV_4.C = clk
+ estadoSBV_6.Q * x
estadoSBV_2.C = clk
20
+ estadoSBV_5.Q * /x
estadoSBV_3.C = clk
Ejemplo # 8
Igual al ejemplo #4, pero añadiéndole:
ATTRIBUTE STATE_ENCODING OF ESTADOS TYPE IS Gray;

-- Proyecto: CSS_1
-- EJ_6
-- 16V8
LIBRARY IEEE;
ENTITY EJ6 IS
W: OUT Std_Logic);
END EJ6;

ATTRIBUTE state_encoding OF Estados: TYPE IS GRAY;
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= H;
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
END CASE;
21
END IF;
END Process;
END;

a := "000";
b := "001";
c := "011";
d := "010";
e := "110";
f := "111";
g := "101";
h := "100";
DESIGN EQUATIONS
w= estadoSBV_0.Q * /estadoSBV_1.Q
estadoSBV_0.D = estadoSBV_1.Q * x * /estadoSBV_2.Q

+ /estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q
+ estadoSBV_0.Q * /x * estadoSBV_2.Q
+ estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
estadoSBV_0.C = clk
estadoSBV_1.D = /estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q

+ /estadoSBV_1.Q * /x * estadoSBV_2.Q
+ estadoSBV_0.Q * /estadoSBV_1.Q * x
+ /estadoSBV_0.Q * estadoSBV_1.Q * x
estadoSBV_1.C = clk
estadoSBV_2.D = estadoSBV_1.Q * x * /estadoSBV_2.Q

+ /estadoSBV_0.Q * x * /estadoSBV_2.Q
+ estadoSBV_0.Q * x * estadoSBV_2.Q
+ /estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
estadoSBV_2.C = clk
Ejemplo # 9
Igual al ejemplo #4, pero con la salida registrada codificada a partir de los bits de estados.
En este caso es necesario realizar la codificación manual garantizando que exista un bit del código que tome el valor 1 solamente
en los estados donde la salida es 1. En los demás estados este bit tuene que ser 0. Lo anterior permite identificar este bit con la
salida de la maquina de estado. En esta maquina la salida es 1 en los estados G y H por tanto una codificación posible es la
siguiente.
Estado Asignación
A 0000
B 0001
C 0011
D 0010
E 0110
F 0111
G 1111
H 1110
22

-- Proyecto: CSS_1
-- EJ_6
-- 16V8
LIBRARY IEEE;
ENTITY EJ6 IS
W: OUT Std_Logic);
END EJ6;

SIGNAL Estado: Std_logic_Vector ( 3 DOWNTO 0);
-- A continuación se escribe la codificación deseada para cada estado
constant A: Std_Logic_Vector ( 3 DOWNTO 0):= "0000";
constant B: Std_Logic_Vector ( 3 DOWNTO 0):= "0001";
constant C: Std_Logic_Vector ( 3 DOWNTO 0):= "0011";
constant D: Std_Logic_Vector ( 3 DOWNTO 0):= "0010";
constant E: Std_Logic_Vector ( 3 DOWNTO 0):= "0110";
constant F: Std_Logic_Vector ( 3 DOWNTO 0):= "0111";
constant G: Std_Logic_Vector ( 3 DOWNTO 0):= "1111";
constant H: Std_Logic_Vector ( 3 DOWNTO 0):= "1110";
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= H;
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
END CASE;
END IF;
23
END Process;
END;
DESIGN EQUATIONS
w= estado_3.Q * estado_2.Q * estado_1.Q
estado_3.D = /estado_3.Q * estado_2.Q * estado_1.Q * x * /estado_0.Q

+ /estado_3.Q * estado_2.Q * estado_1.Q * /x * estado_0.Q
estado_3.C = clk
estado_2.D = /estado_3.Q * estado_1.Q * x * /estado_0.Q

+ /estado_3.Q * /estado_2.Q * estado_1.Q * /estado_0.Q
+ estado_2.Q * estado_1.Q * /x * estado_0.Q
+ estado_3.Q * estado_2.Q * estado_1.Q * estado_0.Q
estado_2.C = clk
estado_1.D = /estado_3.Q * /estado_2.Q * /estado_1.Q * /x * estado_0.Q

+ /estado_3.Q * /estado_2.Q * estado_1.Q * /estado_0.Q
+ estado_2.Q * estado_1.Q * /x * estado_0.Q
+ estado_3.Q * estado_2.Q * estado_1.Q * estado_0.Q
+ estado_2.Q * estado_1.Q * x * /estado_0.Q
+ /estado_3.Q * /estado_2.Q * estado_1.Q * x
estado_1.C = clk
estado_0.D = /estado_3.Q * /estado_2.Q * x * /estado_0.Q

+ /estado_3.Q * estado_1.Q * x * /estado_0.Q
+ estado_2.Q * estado_1.Q * x * estado_0.Q
+ /estado_3.Q * /estado_2.Q * /estado_1.Q * estado_0.Q
estado_0.C = clk
Ejemplo # 10
Igual al ejemplo #4, pero con la salida registrada decodificada a partir de los bits de estados.
Para esto es necesario escribir la tabla de estado excitación de la salida en lugar de la tabla estados /salida.
ES W*
EP X X
0 1 0 1
A A B 0 0
B C B 0 0
C A D 0 0
D E F 0 0
E A G 0 1
F H B 1 0
G E F 0 0
H A D 0 0
24
-- Proyecto: CSS_1
-- EJ_7
-- 16V8
LIBRARY IEEE;
ENTITY EJ7 IS
W: OUT Std_Logic);
END EJ7;

SIGNAL estado: ESTADOS;
BEGIN
PROCESS (CLK)
BEGIN
IF (CLK'Event AND CLK = '1') THEN W<= '0'; -- asignacion por omision
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= E;
END IF;
WHEN E => IF X = '1' THEN estado <= G; W<= '1';
ELSE estado <= A;
END IF;
ELSE estado <= H; W<= '1';
END IF;
ELSE estado <= E;
END IF;
ELSE estado <= A;
END IF;
END CASE;
END IF;
END Process;
END;

a := b"000";
b := b"001";
c := b"010";
d := b"011";
e := b"100";
f := b"101";
g := b"110";
h := b"111";
25
DESIGN EQUATIONS
w.D = x * estadoSBV_0.Q * /estadoSBV_1.Q * /estadoSBV_2.Q

+ /x * estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
w.C = clk
estadoSBV_0.D = /x * estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q

+ /estadoSBV_0.Q * estadoSBV_1.Q * estadoSBV_2.Q
+ x * estadoSBV_0.Q * /estadoSBV_2.Q
+ estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q
estadoSBV_0.C = clk
estadoSBV_1.D = x * estadoSBV_0.Q * /estadoSBV_1.Q * /estadoSBV_2.Q

+ x * /estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q
+ x * estadoSBV_0.Q * estadoSBV_1.Q * estadoSBV_2.Q
+ /x * /estadoSBV_1.Q * estadoSBV_2.Q
estadoSBV_1.C = clk
estadoSBV_2.D = estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q

+ x * estadoSBV_1.Q
estadoSBV_2.C = clk
Ejemplo # 11
Igual al ejemplo #4, pero considerando que la maquina es del tipo Mealy
EP ES,W
X
0 1
A A,0 B,0
B C,0 B,0
C A,0 D,0
D E,0 F,0
E A,0 D,1
F C,1 B,0
Estado Descripción Significado

A Estado inicial, en el no hay ningún bit de secuencia. Nada
B Tenemos el primer bit de secuencia 1
C Tenemos los dos primeros bits de la secuencia 10
D Tenemos los tres primeros bits de la secuencia 101
E Tenemos los cuatros primeros bits de una secuencia 1010
F Tenemos los cuatros primeros bits de la otra secuencia 1011
La salida W es asincrónica, pues cuando se alcanza el estado E o F, W = 1 en función del valor que tenga la entrada X.

-- Proyecto: CSS_1
26
-- EJ_8
-- 16V8
LIBRARY IEEE;
ENTITY EJ8 IS
W: OUT Std_Logic);
END EJ8;

TYPE ESTADOS IS (A,B,C,D,E,F);
SIGNAL estado: ESTADOS;
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
ELSE estado <= A;
END IF;
ELSE estado <= E;
END IF;
WHEN E => IF X = '1' THEN estado <= D;
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;

END CASE;
END IF;
END Process;
-- SALIDA
W <= '1' WHEN estado = E AND X = '1' ELSE
'1' WHEN estado = F AND X = '0' ELSE
'0';
END;

a := b"000";
b := b"001";
c := b"010";
d := b"011";
e := b"100";
f := b"101";
DESIGN EQUATIONS
27
estadoSBV_0.D = estadoSBV_2.Q * estadoSBV_1.Q
estadoSBV_0.C = clk
estadoSBV_2.D = x
estadoSBV_2.C = clk
w= x * estadoSBV_0.Q * /estadoSBV_2.Q
+ /x * estadoSBV_0.Q * estadoSBV_2.Q
estadoSV_1.D = x * estadoSBV_0.Q * /estadoSBV_2.Q

+ /x * estadoSBV_2.Q * /estadoSBV_1.Q
+ x * /estadoSBV_2.Q * estadoSBV_1.Q
estadoSBV_1.C = clk
Ejemplo # 12
Diseñar un circuito secuencial sincrónico con dos entradas X, Y y una sola salida Z. La salida debe ser 1, si el número de unos en las
entradas X y Y desde que la máquina comenzó es múltiplo de 4 y la salida es cero en los otros casos.

-- Proyecto: CSS_1
-- EJ_10
-- 16V8
LIBRARY IEEE;
ENTITY EJ10 IS
PORT (X,Y, CLK: IN Std_logic;
Z: OUT Std_Logic);
END EJ10;

TYPE ESTADOS IS (S0,S1,S2,S3);
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
WHEN S0 => IF (X = '0' AND Y = '0') THEN estado <= S0;
ELSIF (X = '0' AND Y = '1') THEN estado <= S1;
ELSE estado <= S1;
END IF;
ELSE estado <= S2;
END IF;
ELSE estado <= S3;
28
END IF;
ELSE estado <= S0;
END IF;
WHEN OTHERS => estado <= S0;
END CASE;
END IF;
END Process;
Z <= '1' WHEN estado = S0 ELSE '0';
END;

s0 := "00";
s1 := "01";
s2 := "11";
s3 := "10";
DESIGN EQUATIONS
z= /estadoSBV_0.Q * /estadoSBV_1.Q
estadoSBV_0.D = estadoSBV_1.Q * x * /y
+ estadoSBV_1.Q * /x * y
+ estadoSBV_0.Q * /x * /y
+ /estadoSBV_0.Q * x * y
estadoSBV_0.C = clk
estadoSBV_1.D = /estadoSBV_0.Q * /x * y
+ /estadoSBV_0.Q * x * /y
+ /estadoSBV_1.Q * x * y
+ estadoSBV_1.Q * /x
estadoSBV_1.C = clk
Ejemplo # 13
Es una cerradura combinacional, que se abre para una cierta secuencia binaria. Diseñar una máquina secuencial sincrónica con una
entrada X y dos salidas UNLK y HINT. La salida UNLK debe ser 1 si y solo si X = 0 y la secuencia de entradas recibida en los 7
relojes anteriores fue 0110111. La entrada HINT debe ser 1 solo si el valor actual de X es el correcto en la secuencia.
-- Fecha de creacion: 6/03/03

-- Proyecto: CSS_1
-- EJ_11
-- 16V8
LIBRARY IEEE;
ENTITY EJ11 IS
PORT (X,CLK: IN Std_logic;
UNLK, HINT: OUT Std_Logic);
END EJ11;

TYPE ESTADOS IS (A, B, C, D, E, F, G, H);
29
BEGIN
PROCESS (CLK)
BEGIN
CASE estado IS
ELSE estado <= A;
END IF;
ELSE estado <= C;
END IF;
WHEN C => IF X = '0' THEN estado <= C;
ELSE estado <= D;
END IF;
WHEN D => IF X = '0' THEN estado <= E;
ELSE estado <= A;
END IF;
WHEN E => IF X = '0' THEN estado <= B;
ELSE estado <= F;
END IF;
ELSE estado <= G;
END IF;
WHEN G => IF X = '0' THEN estado <= E;
ELSE estado <= H;
END IF;
WHEN H => IF X = '0' THEN estado <= B;
ELSE estado <= A;
END IF;
END CASE;
END IF;
END Process;
-- SALIDA Combinacionales
HINT <= '1' WHEN estado = A and X ='0' ELSE
'1' WHEN estado = B and X ='1' ELSE
'1' WHEN estado = D and X ='0' ELSE
'1' WHEN estado = E and X ='1' ELSE
'1' WHEN estado = F and X ='1' ELSE
'1' WHEN estado = G and X ='1' ELSE
'1' WHEN estado = H and X ='0' ELSE '0';
UNLK <= '1' WHEN estado = H and X ='0' ELSE '0';
END;

a := "000";
b := "001";
c := "011";
d := "010";
e := "110";
f := "111";
g := "101";
h := "100";
DESIGN EQUATIONS
unlk = /x * estadoSBV_0.Q * /estadoSBV_1.Q * /estadoSBV_2.Q
hint = x * estadoSBV_0.Q * estadoSBV_1.Q

30
+ /x * /estadoSBV_0.Q * /estadoSBV_2.Q
estadoSBV_0.D = /x * /estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q

+ x * estadoSBV_0.Q * estadoSBV_1.Q
+ estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
estadoSBV_0.C = clk
estadoSBV_1.D = x * estadoSBV_0.Q * estadoSBV_1.Q * /estadoSBV_2.Q

+ /x * estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
+ /x * /estadoSBV_0.Q * estadoSBV_1.Q
estadoSBV_1.C = clk

+ /estadoSBV_0.Q * /estadoSBV_1.Q * estadoSBV_2.Q
+ estadoSBV_0.Q * estadoSBV_1.Q
estadoSBV_2.C = clk
31
Ejemplo # 14
Diseñe (NO PLD) un circuito con solo dos entradas (X1 y X2) y dos salidas (F1 y F2) El circuito debe comportarse como se
muestra en la figura. Es decir a partir de que X2 = 1 y a partir de la segunda transición positiva de X1 la salida F1 se activa según
se muestra. Y si se mantiene X2=1, a partir de la cuarta transición positiva de X1 la salida F2 se activa según se muestra en el
siguiente gráfico. Lo anterior no se repite hasta que en X2 ocurra otra transición positiva.
Tomando a X1 como la señal de reloj, tenemos:
X1
X2
F1
F2
Estados Estados
Presentes Futuro
X2 Salidas
0 1 F1 F2
S0 S0 S1 0 0
S1 S0 S2 0 0
S2 S0 S3 1 0
S3 S0 S4 1 1
S4 S0 S5 1 1
S5 S0 S6 1 0
S6 S0 S7 1 0
S7 S0 S7 0 0
Estado Estado
Presente Futuro
X2 Salidas
Q3 Q2 Q1 0 1 F1 F2
0 0 0 0 0 0 0 0 1 0 0
0 0 1 0 0 0 0 1 1 0 0
0 1 1 0 0 0 0 1 0 1 0
0 1 0 0 0 0 1 0 0 1 0
1 0 0 0 0 0 1 1 1 1 1
1 1 1 0 0 0 1 1 0 1 0
1 1 0 0 0 0 1 0 1 1 0
1 0 1 0 0 0 1 0 1 0 0
La asignación esta realizada para evitar que en F2 ocurran Hazard, se procuro que los estados S3, S4 y S5 no fueran adyacentes.
32
D1 D2 D3
Q2 Q1 Q2 Q1 Q2 Q1
0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0
X2 Q3 X2 Q3 X2 Q3
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0
0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
1 1 1 1 0 0 1 1 1 0 1 0 1 1 0 0 0 1
1 0 1 1 0 1 1 0 0 1 1 0 1 0 1 1 1 1
Q2 Q1 Q2 Q1
0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0
X2 Q3 X2 Q3
0 0 0 0 0 0 0 0
0 0 0 0
0 1 0 0 0 0 0 1 0 0 0 0
1 1 1 0 1 1 1 1 1 0 1 0
1 0 0 0 1 1 1 0 0 0 0 1
F1 F2
D1 = X2 /Q2 + X2 Q3 Q2 /Q1
D2 = X2 Q3 /Q2 /Q1 + X2 /Q3 Q1 + X Q2 Q1
D3 = X2 /Q3 + X2 Q2 /Q1
F1 = X2 Q2 + X2 Q3 /Q1
F2 = X2 Q3 /Q2 /Q1+ X2 Q3 /Q2 Q1 /X1 + X2 Q3 Q2 Q1 X1
33

Diseño de CSS I PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Diseño de CSS I PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Electrónica Digital II Diseño de Circuitos Secuénciales Sincrónicos

Profesor Víctor Escartín

DISEÑO DE CIRCUITOS SECUENCIALES SINCRÓNICOS

Problemas. 7.30 a 7.32, 7.34, 7.36, 7.41, 7.42

DISEÑO DE CIRCUITOS SECUENCIALES SINCRÓNICOS

Método de diseño de CSS empleando circuitos de bajo nivel de integración.

Diseño de la tabla de estado.

Se presentara el diseño de la tabla de estados a través de un ejemplo:

Figura 1. Tabla de estado primer paso.

Figura 2. Tabla de estado segundo paso.

Observación Estado actual Estado futuro

Figura 3. Tabla de estado tercer paso.

Observación Estado actual Estado futuro

Figura 4. Tabla de estado cuarto paso.

Figura 5. Tabla de estado quinto paso.

Figura 6. Tabla de estado sexto paso.

Figura 7. Tabla de estado séptimo paso.

Figura 8. Tabla de estado no mínima.

Observación Estado actual Estado futuro

Figura 9 Ejemplos de posibles asignaciones de estados.

Síntesis utilizando flip-flops tipo D.

Figura 10. Tabla de transición y de salida.

Figura 11, Tabla de excitación del Flip - Flop D

La salida se obtiene también mediante un mapa de Karnaugh cuyo resultado es:

El último paso es realizar el dibujo del circuito.

Figura 14. Tabla de estado.

En la figura 15 se muestra la tabla de transición / salida.

Figura 15. Tabla de transición / salida.

Tabla de excitación del Flip - Flop D

D1 = Q1 /X /Y + /Q2 /X Y + /Q1 X Y + /Q2 X /Y

Realicemos el ejemplo anterior pero empleando biestables JK.

J1 = /Q2 /Q1 Y + /Q2 /Q1 X + /Q1 X Y K1 = Q2 Q1 Y + Q2 Q1 X + Q1 X Y

J2 = /Q2 Q1 Y + /Q2 Q1 X + /Q2 X Y K2 = Q2 /Q1 Y + Q2 /Q1 X + Q2 X Y

Figura 16, Tabla de estados / salidas.

S*, UNLK HINT

Figura 17, Tabla de transición / salida.

El diseño de un CSS tipo Moore puede realizarse de varias formas.

Método de diseño de CSS, empleando PLD.

Nuevas sentencias del VHDL.

TYPE STATES IS ( Reposo, Espera, Dato, Nodef,Error);

ATTRIBUTE STATE_ENCODING OF ESTADOS TYPE IS one_hot_zero;

State encoding (one-hot zero-state) for 'estado' is:

State encoding (one-hot one-state) for 'estado' is:

State encoding (sequential) for 'estado' is:

State encoding (gray) for 'estado' is:

Descripción de CSS o FSM.

ENTITY EJ_4 IS PORT(

ARCHITECTURE EJ_4 OF EJ_4 IS

State encoding (sequential) for 'nxt_estado' is:

DESIGN EQUATIONS (08:42:36)

estadoSBV_0.D = /x * estadoSBV_0.Q * estadoSBV_1.Q

ENTITY EJ_5 IS PORT(

ARCHITECTURE EJ_5 OF EJ_5 IS

State encoding (sequential) for 'estado' is:

estadoSBV_0.D = /x * estadoSBV_0.Q * estadoSBV_1.Q

A partir del enunciado se obtiene la tabla de estados / salidas.

Estado Descripción Significado

De la tabla de estados / salida podemos escribir el programa en VHDL.

-- Fecha de creación: 26/02/03

ARCHITECTURE A_EJ4 OF EJ4 IS

State encoding (sequential) for 'estado' is:

estadoSBV_0.D = estadoSBV_0.Q * /estadoSBV_1.Q * /x * estadoSBV_2.Q

estadoSBV_1.D = /estadoSBV_0.Q * estadoSBV_1.Q * x * /estadoSBV_2.Q