Cerradura Electrónica Digital

1. Introducción

Para resolver el problema propuesto, es imprescindible utilizar una división del mismo

en pequeños bloques, como se plantea de hecho en el enunciado. En clase se explicaron, por

motivos pedagógicos y de organización docente, primero todos los circuitos combinacionales y

posteriormente todos los secuenciales. Sin embargo aquí se planteará la solución por bloques

temáticos, resolviendo todos los bloques de cada uno de los dos grandes subcircuitos de los que

consta el problema, el CCT y la URC. Dentro de cada una de las dos partes sí que se estudiarán

primero los circuitos combinacionales y tras éstos los secuenciales, dado que parece que éste es

un orden más lógico. Es conveniente recalcar que aquí se propone una posible solución al pro-

blema, que no tiene por qué ser única, ni siquiera ser la mejor. Se anima por tanto a que traten

de buscar soluciones distintas o incluso mejores.

2. Circuito de Codificación y Transmisión (CCT)

Recordemos que el CCT está compuesto por cuatro bloques, dos de ellos combinaciona-

les (CLT y CEP) y otros dos secuenciales (RTx y CTx):

C ircuito deLec tura de l

Tec lado(C LT)

C ircuito deEncriptac ión ygenerac ión de

Paridad(C EP)

C ontro l de laTransmis ión

(C Tx)

R egis trode

Transmis ión(R Tx)

F1

F2

F3

F4

C3C2C1

D3

D2

D1

D0

E0

E1

E2

E3

PE

DS

CLK

Desp

TxO K

PT

Bloqueo

1 2 3

4 5 6

7 8 9

0

C C T

Carga

�������������� �� ������� ����������� ������� ������������� ������������������

2.1. Circuito de Lectura del Teclado (CLT):

Recoge las 7 señales provenientes del teclado y genera el código binario correspondiente

a la tecla pulsada (en el ejemplo anterior, D3-D2-D1-D0=1-0-0-1). Además generará la señal PT

que indica que se ha pulsado una tecla.

Dado que posee 7 entradas, parece poco apropiado acomenter la solución por la técnica

de reducción de Karnaugh, dado que esto provocaría la aparición de tablas de 27=128 filas.

Por otra parte, de hecho el bloque produce un cambio de código, por lo que se podrá

descomponer siempre en un circuito decodificador más un circuito codificador. En nuestro ca-

so, además, el circuito decodificador resulta extremadamente simple, compuesto únicamente

por 10 puertas lógicas AND. Tras esto, el codificador puede ser uno estándar de 16:4, o bien se

puede realizar con una etapa de puertas OR, como se muestra en la figura:

La señal PT se obtiene, como se puede comprobar, simplemente uniendo las cuatro salidas Di

con la salida de U10, que indica que se ha pulsado el “0”. Otra posibilidad sería sumar sólo las

señales Ci, con lo que podríamos asegurar también que se ha pulsado una tecla, pero esta solu-

ción es más general aunque menos compacta; la que ustedes prefieran...

�������������� �� ������� ����������� ������� ������������� ������������������

2.2. Circuito de Encriptación y generación de paridad (CEP):

A partir de la salida del CLT, encripta el dato usando para ello la siguiente fórmula:

Dato encriptado= MOD10(7 x Dato)

Donde la operación MOD10 extrae el módulo en base 10, o lo que es lo mismo el resto de

dividir el número entre paréntesis por 10. Una vez encriptado el dato, se calcula su paridad, ge-

nerando una señal PE que valdrá “1” si el número de bits a 1 del dato encriptado es par y “0” si

es impar.

Para realizar este bloque, comenzamos por calcular el dato encriptado, usando la fór-

mula propuesta. Aplicándola podemos escribir la siguiente tabla de verdad:

Dato D.E. D3-D2-D1-D0 E3-E2-E1-E0 0 0 0-0-0-0 0-0-0-0 1 7 0-0-0-1 0-1-1-1 2 4 0-0-1-0 0-1-0-0 3 1 0-0-1-1 0-0-0-1 4 8 0-1-0-0 1-0-0-0 5 5 0-1-0-1 0-1-0-1 6 2 0-1-1-0 0-0-1-0 7 9 0-1-1-1 1-0-0-1 8 6 1-0-0-0 0-1-1-0 9 3

1-0-0-1 0-0-1-1 A partir de esta tabla, sólo resta aplicar Karnaugh para calcular las expresiones lógicas

de E3, E2, E1 y E0, teniendo en cuenta que las combinaciones de entrada 1010, 1011, 1100, 1101,

1110 y 1111 no se van a producir nunca.

Las tablas de Karnaugh para cada una de las cuatro salidas son:

E3 = D2· (D1· D0+D1· D0)

E2=D3· D1· D0+D3· D0+D2· D1D0

D1-D0 D3-D2

0-0 0-1 1-1 1-0

0-0 0 0 0 0 0-1 1 0 1 0 1-1 -- -- -- -- 1-0 0 0 -- --

D1-D0 D3-D2

0-0 0-1 1-1 1-0

0-0 0 1 0 1 0-1 0 1 0 0 1-1 -- -- -- -- 1-0 1 0 -- --

�������������� �� ������� ����������� ������� ������������� ������������������

E1=D3+D2· D1· D0+D2· D1*D0

La salida E0 se puede comprobar, pos simple inspección que es igual que D0, para los

10 casos analizados, por lo que lo más sencillo será hacerla igual a D0.

Finalmente, el esquema de montaje del circuito de encriptación sería:

Por otro lado, para la generación del bit de paridad, comprobamos que el tipo de pari-

dad pedida es impar, de manera que el bit de paridad hará que el conjunto de los n+1 bits (en

este caso 4+1) tengan siempre paridad impar, esto es un número impar de cifras iguales a “1”.

Para calcular la función de paridad, se comprueban las dos siguientes propiedades:

1.- La función que calcula el bit de paridad impar de un conjunto de 2 bits es una puerta XNOR.

En efecto, una puerta XNOR valdrá “1” cuando las dos entradas sean iguales, esto es cuando el

número de unos sea 0 ó 2. Por tanto, Con una puerta XNOR calculo el bit de paridad impar de

dos bits.

2.- El cálculo del bit de paridad se puede realizar de manera recursiva. Es fácil comprobar que,

si un conjunto de N bits tiene, como bit de paridad impar PN y otro conjunto, en general de M

bits tiene como bit de paridad PM, entonces el bit de paridad del conjunto de M+N bits será la

paridad de los dígitos PN y PM. En efecto, en el caso de que ambos conjuntos tuviesen un núme-

ro par de unos (PN=PM=1) o un número impar de unos (PN=PM=0), el conjunto resultante

D1-D0 D3-D2

0-0 0-1 1-1 1-0

0-0 0 1 0 0 0-1 0 0 0 1 1-1 -- -- -- -- 1-0 1 1 -- --

�������������� �� ������� ����������� ������� ������������� ������������������

tendría un número par de unos con lo que el bit de paridad impar debería valer 1. Sin embargo,

si uno tuviese paridad par y otro impar, la paridad resultante sería impar de donde el bit de

paridad impar debería valer 0.

Aplicando estas dos sencillas reglas, se puede obtener que la función que calcula la pa-

ridad impar de 4 bits se puede realizar con tan solo 3 puertas XNOR, como se muestra en la

figura:

En cualquier caso, si no se entiende el método utilizado, se puede hacer también apli-

cando el método de reducción de Karnaugh, en función de los valores que toman las cuatro

entradas. De esta manera saldrá una solución equivalente aunque probablemente con más puer-

tas lógicas.

2.3. Circuito de Control de la Transmisión (CTx):

Gobernará la transmisión síncrona, iniciando la misma cuando detecte un “1” en PT, y

reiniciándola siempre que no obtenga del receptor un “1” por la línea TxOK. Para ello, generará

las señales Carga y Desp, que harán que el registro de transmisión se cargue con el dato encrip-

tado más el bit de paridad y se desplace, respectivamente. Una vez finalizado el proceso (cuando

se reciba TxOK=1), no se iniciará una nueva transmisión hasta que no se pulse otra tecla, lo que

significará que PT tiene que pasar a “0” y luego nuevamente a “1”.

En caso de que la señal Bloqueo se activase a nivel alto, se bloqueará el proceso de

transmisión de datos, quedando inutilizado el sistema hasta que no vuelva a ser “0”.

El circuito de control de transmisión es, por definición, una máquina de transición de

estados que deberá gobernar al RTx. Observando con detalle el bloque, se comprueba que ten-

dremos que tener en cuenta tres entradas. Esto, en principio, no es una situación deseable a la

hora de diseñar una máquina de estados, dado que el número de combinaciones crece exponen-

cialmente con el número de entradas. Por tanto, puede ser útil tratar de reducir las señales que

entren en la máquina de estados propiamente dicha.

Para ello, nos fijamos en que la entrada BLOQUEO, procedente de la URC, debe impe-

dir que el sistema funcione. Esto es similar a “bloquear” la señal PT, con lo que conseguiríamos

que nuevas pulsaciones del teclado no fuesen atendidas por nuestro sistema al no detectar un

�������������� �� ������� ����������� ������� ������������� �������������� ���

nuevo pulso de PT. Así pues, definimos una nueva señal, PT’ como el producto de PT por

BLOQUEO negada:

Ahora, las entradas a mi máquina de estados serán PT’ y TxOK, siendo el funciona-

miento de la misma como se explica en el siguiente pseudo-código:

1. Espero a que se pulse una tecla (¿PT=1?)

2. Cuando se haya pulsado, cargo el dato en el registro RTx

3. Tras la carga, desplazo durante 5 ciclos de reloj, para transmitir todo el dato por la

línea serie (DS)

4. A continuación, compruebo si el dato llegó correctamenteo (¿TxOK=1?)

5. Si no es así, vuelvo a 3.

6. Si es así, espero a que se desactive PT’, para evitar volver a comenzar el ciclo en fal-

so, y tras esto vuelvo a 1.

Renombrando las entradas, para simplificar la notación, como PT’=P, TxOK=T, la tabla

de transición de estados de la máquina queda como sigue:

ESTADO P-T SALIDAS 0 0 0 1 1 1 1 0 DESP CARGA

0: Reposo (0) (0) 1 1 0 0 1: carga 2 2 2 2 0 1

2: 1er despl. 3 3 3 3 1 0 3: 2º despl. 4 4 4 4 1 0

4: 3er despl. 5 5 5 5 1 0 5: 4º despl. 6 6 6 6 1 0 6: 5º despl. 7 7 7 7 1 0

7: Comprueba 2 0 (7) 2 0 0

Es fácil observar que no se pueden simplificar ninguno de los estados, por lo que el si-

guiente paso será directamente construir la tabla de excitaciones de los biestables. Para ello,

decido realizar la máquina con biestables tipo D, lo que simplificará la realización de la misma.

La asignación de estados se realizará, por defecto, estableciendo el valor binario correspondien-

te a la numeración de cada estado. Esta asignación por defecto simplifica la traducción de la

tabla de transición, aunque conviene pensar previamente si no hay alguna otra codificación que

resulte más ventajosa. Con esto, la tabla de excitación será:

�������������� �� ������� ����������� ������� ������������� ��������������!���

Y a partir de esta tabla se generan las diferentes tablas

de Karnaugh para calcular las entradas de los tres biestables

que codificarán el estado:

Q3=0 Q3=1 P-T Q2-Q1

0 0

0 1

1 1

1 0

P-T Q2-Q1

0 0

0 1

1 1

1 0

0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1 0 0 0 0 0 1 0 1 1 1 1

D3=Q3· Q2· Q1 + Q3· Q2 + Q3· Q1 + Q3· P· T

Q3=0 Q3=1 P-T Q2-Q1

0 0 0 1 1 1 1 0 P-T Q2-Q1

0 0 0 1 1 1 1 0

0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 1 1 1 1 1 1 0 0 0 0 1 1 1 0 1 1 1 0 1 1 1 1 1 0 1 1 1 1

D2=Q2· Q1 + Q2· Q1 + Q3· Q1· T + Q3· Q1· P

Q3=0 Q3=1 P-T Q2-Q1

0 0 0 1 1 1 1 0 P-T Q2-Q1

0 0 0 1 1 1 1 0

0 0 0 0 1 1 0 0 1 1 1 1 0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 1 1 1

D1=Q2· Q1 + Q3· Q1· P + Q3· Q1 + Q3· Q2· P· T

Por último, para terminar de definir la máquina de estados, tenemos que calcular las

ecuaciones del circuito de salida, esto es la relación entre las salidas de los biestables y las sali-

das de la máquina de estado, DESP y CARGA, que dependen únicamente de ellas, al ser una

máquina de Moore.

Por tanto, me fijo en la Tabla de transición de estados, de la que extraigo esta informa-

ción, con la que construyo la tabla de Karnaugh para DESP como:

DESP=Q3· Q1 + Q3· Q2 + Q3· Q2

Para la salida CARGA no es necesario hacer este proceso, dado que

sólo se activa en el estado 1, por lo que directamente podemos deducir que su

Q3 Q2 Q1 P T D3 D2 D1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 0 0 1 1 0 1 0 0 1 0 1 1 0 1 0 1 1 0 1 1 0 1 0 1 0 0 1 1 0 1 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 1 1 1 0 0 0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 1 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0 1 1 0 0 1 0 1 0 1 1 0 1 0 0 1 1 0 1 0 1 0 1 1 1 0 1 0 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 1 0 0 0 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0

Q1 Q3 Q2

0

1

0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1

�������������� �� ������� ����������� ������� ������������� ��������������"���

valor será:

CARGA= Q3· Q2· Q1

El esquemático de la máquina de estados se incluye al final, dado que resulta demasia-

do complejo para incluirlo “a escala”.

2.4. Registro de Transmisión (RTx):

Será un registro paralelo-serie con posibilidad de carga paralela, desplazamiento y para-

da, gobernado por las señales Carga, Desp. Para poder producir la retransmisión del dato en ca-

so de fallo en la misma, tendrá que estar realimentado. La salida DS del RTx será la salida serie

del registro.

Para diseñar el registro de transmisión basta caer en la cuenta de que es, en el fondo, un

registro de desplazamiento, al que tengo que dotar de las siguientes capacidades:

1. Debe poder cargarse en paralelo, adquiriendo los 5 bits que debe transmitir luego

en serie.

2. Debe ser capaz de detener la transmisión o transmitir según le indique un bloque

externo (el CTX).

3. Debe mantener de alguna manera los datos, por si hiciese falta retransmitirlos.

Para realizar estas funciones, voy a necesitar un bloque básico de memoria (biestable) al

que puedan entrar tres señales distin-

tas: o bien el bit anterior (desplaza), o

bien su propio valor (no desplaces) o

bien una entrada externa (carga en

paralelo). Por todo ello, defino la si-

guiente celda básica, formada por un

biestable y un multiplexor 4:1, según

se ve en la figura:

Usando esta celda básica, el

registro RTx queda diseñado sin más que unir en serie 5 de estas celdas, de la manera que se

indica en el dibujo:

�������������� �� ������� ����������� ������� ������������� ��������������#���

De esta forma, queda cerrado ya el diseño del primer bloque, tanto en sus componentes

combinacionales como en sus bloques síncronos.

3. Unidad Remota de Control (URC)

La unidad remota de control (URC) está constituida por 6 bloques, cuatro de ellos se-

cuenciales y dos combinacionales. En gran medida, el diseño de estos bloques estará condicio-

nado por lo ya realizado en el CCT, y viceversa, de manera que no se pueden resolver ambos

subcircuitos de manera totalmente independiente. Un esquema general de la URC es:

M áquina deestados desecuenc iacorrec ta(M ESC )

C omprobac iónde código de

seguridad(C C S)

C ircuito deD esencriptac ión

yC omprobac ión

deParidad(C D P)

Bloqueo de l s is tema(BS)

R egis trode

R ecepc ión(R R x)

A1

A2

DR3

DR2

DR1

DR0

R0

R1

R2

R3

RP

DS

CLK

Desp

TxO K

Bloqueo

Abre

G en.C LK

G enerac ión deseña l de D a to

N uevo(G D N )

DN

URC10

CS0..CS 11

CS

11

CS

0

FALLO

Veamos a continuación cada uno de los diferentes bloques, comenzando nuevamente

por los meramente combinacionales.

�������������� �� ������� ����������� ������� ������������� ��������������$%���

3.1. Circuito de Desencriptación y comprobación de paridad

(CDP):

Este circuito comprobará la paridad del dato recibido y la comparará con el bit de pari-

dad, generando la señal TxOK en caso de que el bit de paridad coincida con el valor calculado en

el receptor, lo que asegura de alguna forma que la transmisión se ha realizado de forma correcta.

Asimismo, este bloque realizará la desencriptación del dato, efectuando la operación inversa a la

realizada por el CEP. Se puede comprobar fácilmente que la desencriptación se realiza usando la

fórmula:

Dato = MOD10(3 x Dato encriptado)

Este bloque generará las salidas DR3...DR0 que serán el dato desencriptado recibido.

Este bloque será análogo al ya realizado previamente en el CEP, teniendo que imple-

mentar las operaciones inversas. Para la desencriptación, utilizaré la fórmula que se ofrece

comprobando que, en efecto, produce los códigos de origen a partir del dato encriptado.

D.E. Dato R3-R2-R1-R0 DR3-DR2-DR1-DR0 0 0 0-0-0-0 0-0-0-0 1 3 0-0-0-1 0-0-1-1 2 6 0-0-1-0 0-1-1-0 3 9 0-0-1-1 1-0-0-1 4 2 0-1-0-0 0-0-1-0 5 5 0-1-0-1 0-1-0-1 6 8 0-1-1-0 1-0-0-0 7 1 0-1-1-1 0-0-0-1 8 4 1-0-0-0 0-1-0-0 9 7

1-0-0-1 0-1-1-1 Con los que las tablas de Karnaugh, ahora para los datos recibidos en función de las en-

tradas R:

DR3=R2· R1· R0 + R3· R1· R0

DR2= R3 + R2· R1· R0 + R2· R1· R0

R1-R0 R3-R2

0-0

0-1

1-1

1-0

0-0 0 0 1 0 0-1 0 0 0 1 1-1 -- -- -- -- 1-0 0 0 -- --

R1-R0 R3-R2

0-0

0-1

1-1

1-0

0-0 0 0 0 1 0-1 0 1 0 0 1-1 -- -- -- -- 1-0 1 1 -- --

�������������� �� ������� ����������� ������� ������������� ��������������$$���

DR1= R2· R1· R0 + R2· R1· R0 + R2· R1· R0

De nuevo, DR0 será igual a R0, como no podía ser de otra forma. Por otro lado, para

comprobar la paridad del dato recibido, el circuito será completamente análogo al utilizado

para calcular el bit de paridad impar, de manera que calcularemos el valor esperado del bit de

paridad y lo compararemos. Con esto, el circuito completo quedará como se observa en la figu-

ra siguiente:

Con lo que quedará completado el circuito pedido.

R1-R0 R3-R2

0-0

0-1

1-1

1-0

0-0 0 1 0 1 0-1 1 0 0 0 1-1 -- -- -- -- 1-0 0 1 -- --

�������������� �� ������� ����������� ������� ������������� ��������������$����

3.2. Circuito de Comprobación de Código de Seguridad (CCS):

Este circuito realizará la comparación del dato de 4 bits con los 3 datos que componen la

combinación. Estos tres datos, cada uno de ellos de 3 bits, se fijarán con un conjunto de 12 inter-

ruptores que producirán un “1” en caso de estar abiertos y un “0” en caso de estar cerrados. A

efectos del bloque, supondremos que estos datos son fijos y presentes en las líneas CS11...CS0.

En nuestro caso CS11...CS0=1001-0110-0111, por lo que el código que habrá que in-

sertar será, en decimal y por este orden: 9-6-7

El circuito codificará en las líneas A1 y A2 el acierto de alguno de estos tres caracteres

de la siguiente forma:

Caso A1-A2 Ninguno de los tres 0-0 Primer carácter 0-1 Segundo carácter 1-1 Tercer carácter 1-0

Este circuito, puramente combinacional, debe producir dos salidas que codifican si se

ha acertado alguno de los tres dígitos que componen la combinación, y en ese caso cuál de los

dígitos es. Para ello, será de gran utilidad definir un bloque comparador de igualdad de núme-

ros de 4 bits. Para comparar números de 1 bit usaríamos una puerta XNOR, ya que como se ha

visto dicha puerta vale “1” sólo cuando ambas entradas son iguales. Para extender la compara-

ción a números de 4 bits, lo único que habrá que hacer será utilizar 4 puertas XNOR, con las que

compararé que cada bit de ambos datos sean iguales, y posteriormente una etapa de puertas

AND (o una puerta AND de 4 entradas) para multiplicar estas salidas de las XNOR, con lo que

obtendré un “1” sólo si los 4 bits de ambos datos coinciden. Por tanto, el bloque descrito será

como se observa en la figura.

�������������� �� ������� ����������� ������� ������������� ��������������$����

En función del bloque descrito, el CCS lo puedo construir con tres bloques, que compa-

rarán si el dato introducido es igual al primer dígito, al segundo o al tercero, produciendo las

señales intermedias 1D, 2D, 3D, en función de las cuales ya podré calcular las señales A1 y A2.

Para ello, la tabla de verdad que relaciona 1D, 2D, 3D con A1 y A2 será:

1C 2C 3C A1 A2 0 0 0 0 0 0 0 1 1 0 0 1 0 1 1 0 1 1 -- -- 1 0 0 0 1 1 0 1 -- -- 1 1 0 -- -- 1 1 1 -- --

Realizando la simplificación de Karnaugh con esta tabla, se obtiene fácilmente que A1 y

A2 serán:

A1=2C + 3C

A2=1C + 2C

Con lo que el CCS, finalmente será:

�������������� �� ������� ����������� ������� ������������� ��������������$����

3.3. Registro de Recepción (RRx):

Este registro irá recogiendo los datos serializados en DS, siempre que la señal Desp esté

activa. Las salidas de los 5 bits (los 4 que conforman el dato más el de paridad) estarán accesibles

en todo momento por el siguiente bloque.

Para construir el registro de recepción seguiremos una técnica muy similar a la emplea-

da para el registro de transmisión, con la salvedad de que ahora no es necesario producir la

carga paralela. Por tanto, bastará utilizar un biestable y un multiplexor 2:1 por cada celda, tras

lo que el registro quedará definido por la conexión de 5 bloques como el que se muestra en la

figura:

Usando este bloque, el RRx queda constituido como:

3.4. Generación de señal de Dato Nuevo (GDN):

Este bloque tiene como única misión la generación de una señal, DN, que estará activa

durante un solo ciclo de reloj cada vez que se reciba correctamente un dato nuevo. Esta señal es

de vital importancia para la máquina de estados que controla todo el proceso. Para ello contará

como entradas con las señales Desp y TxOK.

Para la realización de este bloque planteamos una pequeña máquina de estado, que en

función de las señales TxOK y DESP informa de la llegada de un dato nuevo a la máquina de

�������������� �� ������� ����������� ������� ������������� ��������������$����

estado de comprobación de la combinación. Esta pequeña máquina es necesaria para saber

cuándo el dato presente corresponde con una nueva pulsación, y cuándo se debe al último valor

que se recibió anteriormente.

Esta máquina permanecerá en reposo mientras no se produzca una activación de la lí-

nea DESP, que indicará que ha comenzado la transmisión. Tras esto, esperaremos a que se des-

active dicha señal, y comprobaremos que la señal TxOK esté a “1”, con lo que sabremos que se

ha finalizado correctamente la transmisión. En caso contrario, esperaremos de nuevo a que

DESP se active y desactive. Renombrando las entradas para simplificar, como anteriormente

(DESP->D; TxOK->T), la tabla de transición de estados será:

D-T ESTADO 0-0 0-1 1-1 1-0 DN

0: reposo (0) (0) 1 1 0 1: Desplazando 0 2 (1) (1) 0

2: Recibido -- 0 -- -- 1

Codificando los estados por su valor binario, obtenemos la tabla de excitaciones como:

Aplicando nuevamente Karnaugh para calcular D1 y

D0, se obtiene que:

D1=Q0· D· T

D0=D

Mientras que la salida, DN resulta ser igual a Q1. Así

pues, el circuito GDN queda reducido a:

Las señales de Preset y Clear de ambos biestables, que deben estar conectadas a “1” pa-

ra que no actúen, no se han pintado por claridad.

Es fácil ver que la entrada del segundo biestable (U2) sólo estará a 1 en el caso de que, al

pasar DESP de 1 a 0 (con lo que la salida de U1 sigue siendo 1 pero la salida de U4 ya vale 1) sea

Q1 Q0 D T D1 D0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 0 1 1 0 0 1 1 1 0 1 0 1 1 0 0 1 1 0 0 0 -- -- 1 0 0 1 0 0 1 0 1 1 -- -- 1 0 1 0 -- -- 1 1 0 0 -- -- 1 1 0 1 -- -- 1 1 1 1 -- -- 1 1 1 0 -- --

�������������� �� ������� ����������� ������� ������������� ��������������$ ���

TxOK igual a 1. Entonces, se activará DN desactivándose al siguiente ciclo dado que la salida de

U1 ya será 0.

3.5. Bloqueo del Sistema (BS):

Este bloque irá contando los fallos que se producen en la introducción de la combinación

correcta. En caso de que se llegue a 3 fallos consecutivos, se activará la señal Bloqueo a nivel al-

to, impidiendo la operación del sistema hasta que no se resetee el mismo.

Este bloque se puede realizar como una máquina de estados, cuyas entradas sería FA-

LLO y ABRE, con una duración de un único pulso de reloj, y que al llegar a tres fallos activase

la señal BLOQUEO. En caso de que se acertase la combinación, debería volver a la condición de

reposo. De esta manera, la tabla de transición de estados sería:

FALLO-ABRE 0 0 0 1 1 1 1 0 BLOQUEO

0: reposo (0) (0) -- 1 0 1: un fallo (1) 0 -- 2 0 2: dos fallos (2) 0 -- 3 0 3: tres fallos (3) (3) (3) (3) 1

Sin embargo, otra manera, tal vez más sencilla de hacerlo, sería utilizando un contador

con entrada de habilitación de cuenta. Este tipo de contadores se pueden realizar de muchas

formas, siendo la más sencilla usar algún tipo de celda encadenable, como la utilizada en la

práctica de simulaciones de contadores síncronos:

Usando esta celda encadenable, el contador de 2 bits que necesito lo consigo sin más

que poner dos celdas y una puerta AND. Por otra parte, la señal de Reset del contador estará

activada por la señal de ABRE, mientras que la señal de Cambia del primer bit será justamente

la señal FALLO:

�������������� �� ������� ����������� ������� ������������� ��������������$!���

Con esto ya estaría cerrado este bloque.��

3.6. Máquina de Estados de Secuencia Correcta (MESC):

Esta máquina de estados tendrá como entradas las señales A1, A2 que codifican si el da-

to introducido es o no coincidente con alguno de la secuencia y la señal ND, que informa que el

dato ha cambiado. Tendrá que ser capaz de generar la señal Abre cuando detecte que la secuencia

es la correcta, así como generar la señal FALLO en caso de que alguna entrada no sea correcta.

Es importante notar que la señal ND sólo permanece activa un ciclo de reloj, y que tardará al

menos 5 ciclos de reloj en volverse a activar (dado que tendría que llegar un nuevo dato). Esta

máquina de estados puede resultar dependiente de 6 variables. Se explicará como proceder en ese

caso especial.

El último bloque que queda por resolver es la máquina de estados que gobierna la com-

probación de la secuencia correcta. Las entradas de ésta son A1 y A2, que provienen del CCS,

así como DN, que informa que A1 y A2 se refieren a un nuevo dato, a una nueva pulsación del

teclado.

En principio, sería deseable reducir en número de entradas, de manera similar a lo ya

efectuado en el CTx. Sin embargo, en este caso resulta muy complicada la simplificación, con lo

que tendré que montar la tabla de transición de estados teniendo en cuenta simultáneamente las

tres entradas. El funcionamiento de la máquina se puede describir como:

1. Mientras DN sea 0, permanezco en el estado en el que esté, salvo que sea un es-

tado inestable (de señalización de fallo o de abrir).

�������������� �� ������� ����������� ������� ������������� ��������������$"���

2. Cuando DN se activa, compruebo si el dato nuevo corresponde a la secuencia

pedida o no. En caso negativo, voy a un estado de “error”, y en caso afirmativo

sigo la secuencia.

3. Si completo la secuencia, activaré la señal ABRE durante un ciclo de reloj (esta-

do inestable) y volveré al reposo.

4. Si observo un fallo, activaré la señal FALLO durante un ciclo de reloj (también

estado inestable) y volveré al reposo.

De esta manera, la tabla de transición de estados queda:

DN- A1-A2 000 001 010 011 100 101 110 111 F A

(0): Reposo (0) (0) (0) (0) 4 1 4 4 0 0 (1): Llegó 1º bien (1) (1) (1) (1) 4 4 4 2 0 0 (2): Llegó 2º bien (2) (2) (2) (2) 4 4 3 4 0 0 (3): Llegó 3º bien 0 0 0 0 -- -- -- -- 0 1

(4): Fallo 0 0 0 0 -- -- -- -- 1 0

Finalmente, observamos que tendremos que manejar 5 estados (3 variables de estado) y

3 entradas, por lo que la máquina depende en efecto de 6 variables. En principio, esto no intro-

duce ninguna complicación conceptual adicional sobre las máquinas de 5 variables. Ciertamen-

te, sí que será bastante más pesado de resolver, pero el método no es más que una simple exten-

sión de lo ya visto hasta el momento.

Lo primero que habrá que hacer es asignar variables de estado. Realizando dicha asig-

nación según la codificación binaria del número del estado (codificación por defecto), se obtiene

la tabla de excitaciones que se observa en la siguiente página.

Ahora, habrá que realizar la simplificación por Karnaugh de cada una de las tres entra-

das a los biestables, en función de 6 variables.

Para ello, realizaré 4 tablas, de a variables

cada una, y las “superpondré” según el valor de

las otras dos variables, de manera análoga a lo que

se hacía para 5 variables. De esta manera, tendré

adyacencias según las tres dimensiones. En concre-

to, según se ve en el dibujo, la combinación Q3-Q2-

Q1-DN-A1-A2 igual a 0-0-1-1-1-1 será adyacente

con 6 combinaciones distintas, variando cada vez

sólo un bit. Esto corresponde con “moverse” por la

tabla en horizontal (0-0-1-1-1-0 y 0-0-1-1-0-1), en

vertical (0-0-0-1-1-1 y 0-1-1-1-1-1) o bien “moverse”

�������������� �� ������� ����������� ������� ������������� ��������������$#���

en sentido perpendicular a las tablas, lo que representa las combinaciones 0-0-1-0-1-1 y 1-0-1-1-

1-1.

Por tanto, si situamos las cuatro tablas formando

un cuadro, de manera ordenada, podremos observar bas-

tante claramente cuáles son las combinaciones adyacentes:

Usando esta técnica se resuelven las ecuaciones

para calcular D3, D2 y D1 como:

D1=Q2· Q1· DN + Q2· Q1· A1· A2· DN +Q2· A1· A2· DN

Q3-Q2-Q1 D-A2-A1 D3-D2-D1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 1 1 0 1 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

1 0 0 1 0 1 1 1 1 1 1 0

1 0 0 0 0 1 1 0 0 1 0 0

0 0 1 0 0 1 0 0 1 0 0 1

0 0 0 0 0 1 0 1 1 0 1 0

0 0 1 0 0 1 0 0 1 0 0 1

0 0 1 0 0 1 0 0 1 0 0 1

1 0 0 1 0 1 1 1 1 1 1 0

1 0 0 1 0 0 1 0 0 0 1 0

0 1 0 0 1 0 0 1 0 0 1 0

0 0 0 0 0 1 0 1 1 0 1 0

0 1 0 0 1 0 0 1 0 0 1 0

0 1 0 0 1 0 0 1 0 0 1 0

1 0 0 1 0 1 1 1 1 1 1 0

1 0 0 1 0 0 0 1 1 1 0 0

0 1 1 0 1 1 0 1 1 0 1 1

0 0 0 0 0 1 0 1 1 0 1 0

0 0 0 0 0 0 0 0 0 0 0 0

0 1 1 0 1 1 0 1 1 0 1 1

1 0 0 1 0 1 1 1 1 1 1 0

- - - - - - - - - - - -

1 0 0 1 0 0 1 0 0 1 0 0

0 0 0 0 0 1 0 1 1 0 1 0

0 0 0 0 0 0 0 0 0 0 0 0

1 0 0 1 0 0 1 0 0 1 0 0

1 0 0 1 0 1 1 1 1 1 1 0

- - - - - - - - - - - -

1 0 1 x x x - - - 1 1 1 x x x - - - 1 1 0 x x x - - -

Q3=0; DN=0 Q3=0; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 00 01 01 11 11 10 10

Q3=1; DN=0 Q3=1; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 00 01 01 11 11 10 10

Q3=0; DN=0 Q3=0; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 0 1 0 0 01 1 1 1 1 01 0 0 0 0 11 0 0 0 0 11 -- -- -- -- 10 0 0 0 0 10 0 0 1 0

Q3=1; DN=0 Q3=1; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 -- -- -- -- 01 -- -- -- -- 01 -- -- -- -- 11 -- -- -- -- 11 -- -- -- -- 10 -- -- -- -- 10 -- -- -- --

�������������� �� ������� ����������� ������� ������������� ���������������%���

Q3=0; DN=0 Q3=0; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 0 0 0 0 01 0 0 0 0 01 0 0 0 1 11 0 0 0 0 11 -- -- -- -- 10 1 1 1 1 10 0 0 1 0

Q3=1; DN=0 Q3=1; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 -- -- -- -- 01 -- -- -- -- 01 -- -- -- -- 11 -- -- -- -- 11 -- -- -- -- 10 -- -- -- -- 10 -- -- -- --

D2=Q2· Q1· DN +Q2· A1· A2· DN +Q1· A1· A2· DN

Q3=0; DN=0 Q3=0; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 1 0 1 1 01 0 0 0 0 01 1 1 1 0 11 0 0 0 0 11 -- -- -- -- 10 0 0 0 0 10 1 1 0 1

Q3=1; DN=0 Q3=1; DN=1 A1-A2 Q2-Q1

00 01 11 10 A1-A2 Q2-Q1

00 01 11 10

00 0 0 0 0 00 -- -- -- -- 01 -- -- -- -- 01 -- -- -- -- 11 -- -- -- -- 11 -- -- -- -- 10 -- -- -- -- 10 -- -- -- --

D3=A1· A2· DN +A1· Q2· DN +A2· Q1· DN +A2· Q2· DN +Q1· Q2· A1· DN

Por último, las salidas de la máquina de estado, en función del estado, se obtienen de

manera inmediata:

FALLO=Q3

ABRE=Q2· Q1

A continuación, se ofrecen los esquemáticos de esta máquina de estados y de la del CTx,

con lo que queda finalizado el problema.

Se deja como ejercicio para el “lector” la posibilidad de resolver esta máquina de mane-

ra alternativa: tomando la señal DN como habilitador del reloj, usando biestables con habilita-

ción del reloj, e implementando circuitos externos para la generación correcta de las salidas F y

A, que deben durar un solo ciclo de reloj.

PR

EB

CLR

B

CLK

DQ

QB

U1

PR

EB

CLR

B

CLK

DQ

QB

U2

PR

EB

CLR

B

CLK

DQ

QB

U3

U20

1

U31

U32

U33

U34

U35

U36

U37

U38

U39

U40

U41

U42

U43

U44

U45

U46

U47

AB

RE

FA

LLO

CLR

CLK

A2

A1

DN

Q3

Q2

Q1

Máq

uina

de

Est

ados

ME

SC

CE

SA

R V

.1.0

M.A

.P.E

01/2

1/03

shee

t 1 o

f 1

PR

EB

CLR

B

CLK

DQ

QB

U1

PR

EB

CLR

B

CLK

DQ

QB

U2

PR

EB

CLR

B

CLK

DQ

QB

U3

U4U

5U6

U8

U9

U10

U11

U12U13

U14

U15

U16

U17

U18

U19

U20

1U

22

U23

U24 U

25

U26

U27

U28

U29

U30

_TX

OK

_PT

CA

RG

A

DE

SP

Q3

Q2

Q1

Máq

uina

de

Est

ados

CT

xC

ES

AR

V.1

.0M

.A.P

.E01

/21/

03sh

eet 1

of 1