Exercicis d'electrònica digital seqüencial — Tecnologia i Enginyeria 2n Batxillerat

El criteri és la memòria: en un circuit combinacional la sortida depèn només de les entrades que hi ha en aquell moment; en un de seqüencial depèn també de l'estat anterior, de la «història» del circuit.

a) Combinacional: cada combinació d'entrada dona sempre la mateixa sortida.
b) Seqüencial: el valor del compte depèn de les voltes anteriors.
c) Combinacional: la suma només depèn dels dos nombres presents a l'entrada.
d) Seqüencial: ha de recordar quins dígits s'han introduït fins ara.
e) Combinacional: la sortida és una de les entrades triada per les línies de selecció.
f) Seqüencial: el canal següent depèn del canal actual, que s'ha de recordar.
g) Seqüencial: cada bit guarda el valor que tenia el bit veí en el flanc anterior.

El component que emmagatzema un bit és el biestable (flip-flop). Un circuit seqüencial és, en general, un conjunt de biestables més una lògica combinacional que calcula l'estat següent i les sortides.

a) Cada porta NOR dona 1 només quan les seves dues entrades valen 0. Resultat:
1) (S, R) = (0, 0) → Q = 0, $\overline{Q} = 1$
2) (S, R) = (1, 0) → Q = 1, $\overline{Q} = 0$
3) (S, R) = (0, 0) → Q = 1, $\overline{Q} = 0$
4) (S, R) = (0, 1) → Q = 0, $\overline{Q} = 1$
5) (S, R) = (0, 0) → Q = 0, $\overline{Q} = 1$
6) (S, R) = (1, 0) → Q = 1, $\overline{Q} = 0$
7) (S, R) = (1, 0) → Q = 1, $\overline{Q} = 0$
8) (S, R) = (0, 0) → Q = 1, $\overline{Q} = 0$

b) S (set) posa Q a 1; R (reset) posa Q a 0. Amb (0, 0) el latch manté l'estat anterior: aquesta és la seva memòria.

c) Si S = R = 1, les dues portes NOR donen 0: Q = 0 i $\overline{Q} = 0$, dues sortides que haurien de ser complementàries. A més, si les dues entrades passen alhora a 0, l'estat final és imprevisible (depèn de quina porta sigui una mica més ràpida). Per això la combinació S = R = 1 és prohibida.

a) Amb S = 1, R = 0 el biestable es posa a 1; amb S = 0, R = 1 es posa a 0; amb (0, 0) manté l'estat.
Flanc 1: S = 1, R = 0 → Q = 1
Flanc 2: S = 0, R = 0 → Q = 1
Flanc 3: S = 0, R = 1 → Q = 0
Flanc 4: S = 1, R = 0 → Q = 1
Flanc 5: S = 0, R = 0 → Q = 1
Flanc 6: S = 0, R = 1 → Q = 0

b) No. Un biestable síncron només «mira» les entrades en el flanc de rellotge; tot el que passi a S o R entre dos flancs és ignorat. Aquesta és la diferència amb el latch asíncron de l'exercici anterior, que reacciona en qualsevol moment.

c) S = R = 1, perquè no defineix un estat (Q i $\overline{Q}$ haurien de valer alhora 1 i 0).

a) Flanc 1: T = 1 → Q = 1
Flanc 2: T = 1 → Q = 0
Flanc 3: T = 0 → Q = 0
Flanc 4: T = 1 → Q = 1
Flanc 5: T = 0 → Q = 1
Flanc 6: T = 0 → Q = 1
Flanc 7: T = 1 → Q = 0
Flanc 8: T = 1 → Q = 1

b) Amb T = 1, Q canvia a cada flanc de pujada, de manera que fa un cicle complet (0 → 1 → 0) cada dos períodes de rellotge: $f_{Q}$ = 12 kHz / 2 = 6 kHz. Q està 1 durant un període del rellotge i 0 durant el següent, és a dir, el 50 % del temps.

c) Cada biestable divideix la freqüència per 2: 12 kHz / $2^{3}$ = 1,5 kHz.

a) Q⁺ per (J, K):
(0, 0): Q⁺ = Q → manté (0 → 0, 1 → 1).
(0, 1): Q⁺ = 0 → reset (0 → 0, 1 → 0).
(1, 0): Q⁺ = 1 → set (0 → 1, 1 → 1).
(1, 1): Q⁺ = $\overline{Q}$ → bascula (0 → 1, 1 → 0).

b) Mirant a quines files es produeix cada transició:
0 → 0: (J, K) = (0, 0) o (0, 1) ⇒ J = 0, K = X.
0 → 1: (1, 0) o (1, 1) ⇒ J = 1, K = X.
1 → 0: (0, 1) o (1, 1) ⇒ J = X, K = 1.
1 → 1: (0, 0) o (1, 0) ⇒ J = X, K = 0.
Aquesta taula d'excitació és l'eina que s'usa per dissenyar comptadors i màquines d'estats amb biestables JK.

a) Latch D: mentre CLK = 1 (0–4 ms i 8–12 ms), Q = D; durant 4–8 ms manté el valor que tenia a 4 ms (D = 0 en aquest instant).
Biestable D: només mostreja D en els flancs de pujada (0 ms i 8 ms): a 0 ms, D = 0 → Q = 0 fins a 8 ms; a 8 ms, D = 1 → Q = 1 fins al flanc següent.
t = 0,5 ms: latch Q = 0, biestable Q = 0
t = 1,5 ms: latch Q = 1, biestable Q = 0
t = 3,0 ms: latch Q = 0, biestable Q = 0
t = 6,0 ms: latch Q = 0, biestable Q = 0
t = 8,5 ms: latch Q = 1, biestable Q = 1
t = 10,0 ms: latch Q = 0, biestable Q = 1

b) El biestable D, perquè només «mira» D en un instant concret (el flanc) i ignora tot el que passi entre dos flancs. El latch, mentre és transparent, deixa passar qualsevol canvi (com el pols d'1 a 2,5 ms) cap a la sortida.

a) $2^{5}$ = 32 estats; $2^{12}$ = 4096 estats.

b) Calen 100 estats: $2^{6}$ = 64 és insuficient i $2^{7}$ = 128 ≥ 100, de manera que calen 7 biestables.

c) Calen 60 estats: $2^{5}$ = 32 < 60 ≤ $2^{6}$ = 64, de manera que calen 6 biestables.

d) 1000 estats: $2^{9}$ = 512 < 1000 ≤ $2^{10}$ = 1024, de manera que calen 10 biestables.

e) Amb 4 biestables hi ha 16 estats i se'n fan servir 10, de manera que 6 estats no s'utilitzen (de 1010 a 1111). En el disseny d'un comptador cal decidir què fa el circuit si, per un soroll, entra en un d'aquests estats.

a) A cada flanc, $Q_{0}^{+} = x$, $Q_{1}^{+} = Q_{0}$, $Q_{2}^{+} = Q_{1}$, $Q_{3}^{+} = Q_{2}$:
Flanc 1: entrada = 1 → Q₀Q₁Q₂Q₃ = 1000
Flanc 2: entrada = 0 → Q₀Q₁Q₂Q₃ = 0100
Flanc 3: entrada = 1 → Q₀Q₁Q₂Q₃ = 1010
Flanc 4: entrada = 1 → Q₀Q₁Q₂Q₃ = 1101
Flanc 5: entrada = 0 → Q₀Q₁Q₂Q₃ = 0110
Flanc 6: entrada = 0 → Q₀Q₁Q₂Q₃ = 0011
Flanc 7: entrada = 1 → Q₀Q₁Q₂Q₃ = 1001

b) Després del quart flanc, Q₀Q₁Q₂Q₃ = 1101; llegit de Q₃ a Q₀ és 1011, que són els quatre primers bits d'entrada en l'ordre en què van arribar (1, 0, 1, 1) (el primer bit rebut és ara a Q₃). El registre ha convertit quatre bits que arribaven en sèrie en una paraula de quatre bits disponible en paral·lel.

c) Un bit present a l'entrada necessita 4 flancs per arribar a Q₃ (un per biestable): t = 4 · T = 4 / 2000 Hz = 2 ms.

a) Restant 1 a cada flanc, en binari: 100, 011, 010, 001, 000, 111, 110, 101 (de 101 a 100, 011, 010, 001, 000, 111, 110 i de nou 101).

b) Té $2^{3}$ = 8 estats; és un comptador de mòdul 8 i després de 8 flancs torna a l'estat inicial.

c) Com que la seqüència es repeteix cada 8 flancs, només importa el residu de 100 entre 8: 100 = 12 · 8 + 4. Després de 100 flancs és com després de 4: 101 − 4 = 001. (Comprovació: (5 − 100) mod 8 = 1, és a dir, 001.)

1) CLEAR = 0 (actiu): Q = 0 sense esperar cap flanc
2) Flanc de baixada 1 (J = K = 1): bascula → Q = 1
3) Flanc de baixada 2: bascula → Q = 0
4) PRESET = 0 (actiu): Q = 1 immediatament
5) Flanc de baixada 3 amb PRESET encara actiu: Q = 1 (les entrades asíncrones manen)
6) PRESET = 1 de nou; flanc de baixada 4 (J = K = 1): bascula → Q = 0
7) J = K = 0; flanc de baixada 5: manté → Q = 0
8) J = 1, K = 0; flanc de baixada 6: set → Q = 1

Serveixen per portar el circuit a un estat inicial conegut quan s'engega (per exemple, posar tot un comptador a zero amb un únic senyal de reset), perquè en connectar l'alimentació els biestables arrenquen en estats aleatoris.

a) Flanc 1: J = 1, K = 0 → Q = 1
Flanc 2: J = 0, K = 0 → Q = 1
Flanc 3: J = 1, K = 1 → Q = 0
Flanc 4: J = 0, K = 1 → Q = 0
Flanc 5: J = 0, K = 0 → Q = 0
Flanc 6: J = 1, K = 1 → Q = 1
Flanc 7: J = 1, K = 1 → Q = 0
Flanc 8: J = 0, K = 1 → Q = 0
Accions: flanc 1, set; 2, manté; 3, bascula; 4, reset; 5, manté; 6, bascula; 7, bascula; 8, reset.

b) Q canvia als flancs 1 (0 → 1), 3 (1 → 0), 6 (0 → 1) i 7 (1 → 0): 4 vegades.

c) Q val 1 després dels flancs 1, 2 i 6, és a dir, durant 3 dels 8 períodes: 3 · 10 µs = 30 µs d'un total de 80 µs (37,5 %).

a) Per a cada bit, la transició Q → Q⁺ demana, segons la taula d'excitació (0→0: J=0,K=X; 0→1: J=1,K=X; 1→0: J=X,K=1; 1→1: J=X,K=0):
Q₁Q₀ = 00 → 01: J₁ = 0, K₁ = X; J₀ = 1, K₀ = X
Q₁Q₀ = 01 → 10: J₁ = 1, K₁ = X; J₀ = X, K₀ = 1
Q₁Q₀ = 10 → 11: J₁ = X, K₁ = 0; J₀ = 1, K₀ = X
Q₁Q₀ = 11 → 00: J₁ = X, K₁ = 1; J₀ = X, K₀ = 1

b) J₀: 1, X, 1, X → J₀ = 1. K₀: X, 1, X, 1 → K₀ = 1. Per al bit de més pes, J₁: 0, 1, X, X → $J_{1} = Q_{0}$. K₁: X, X, 0, 1 → $K_{1} = Q_{0}$. Així, Q₀ bascula a cada flanc i Q₁ bascula només quan Q₀ = 1.

c) Partint de 00: 01, 10, 11, 00, 01, 10. És la seqüència binària ascendent, i després de 11 torna a 00.

d) En el comptador síncron tots els biestables reben el flanc alhora i totes les sortides canvien simultàniament (amb un petit retard comú). En l'asíncron, la sortida d'un biestable fa de rellotge del següent: els canvis es propaguen un darrere l'altre, i durant un instant el comptador pot passar per estats intermedis incorrectes.

a) Seqüència: 1000 → 0100 → 0010 → 0001 → 1000. Té 4 estats (un per biestable): l'únic 1 «viatja» pel registre. $Q_{0}$ val 1 durant un únic flanc de cada quatre: 0,5 s. El seu període és 4 flancs = 2 s. Aquest tipus de comptador s'utilitza per activar quatre dispositius de manera seqüencial (per exemple, quatre llums que s'encenen una darrere l'altra).

b) Seqüència: 0000 → 1000 → 1100 → 1110 → 1111 → 0111 → 0011 → 0001 → 0000. Té 8 estats. $Q_{0}$ val 1 durant 4 flancs seguits i 0 durant 4 flancs: període de 8 flancs = 4 s.

c) Amb n biestables, el Johnson té 2n estats (8 amb 4 biestables) i l'anell, només n (4). Així s'obté un comptador de més mòdul amb els mateixos biestables. Pel que fa a l'anell, si entra a 0000 hi queda atrapat per sempre (cada biestable recull un 0 i no hi ha cap 1 per «viatjar»): cal inicialitzar-lo amb una entrada de preset o amb una lògica de correcció.

a) Volem $Q^{+} = T \oplus Q$, i un biestable D dona $Q^{+} = D$. Per tant, $D = T \oplus Q$: una porta XOR amb entrades T i Q i sortida a D.
Comprovació: (T, Q) = (0, 0) → D = 0 (manté 0); (0, 1) → D = 1 (manté 1); (1, 0) → D = 1 (bascula a 1); (1, 1) → D = 0 (bascula a 0).

b) Igualant $D = J\,\overline{Q} + \overline{K}\,Q$ amb J = D i $K = \overline{D}$: $J\overline{Q} + \overline{K}Q = D\overline{Q} + DQ = D$. Cal posar J = D i K = D negada (amb un inversor).
Comprovació: D = 1 → (J, K) = (1, 0): set, Q⁺ = 1. D = 0 → (J, K) = (0, 1): reset, Q⁺ = 0.

c) Si J = K = T: $Q^{+} = T\overline{Q} + \overline{T}Q = T \oplus Q$: amb T = 0 manté i amb T = 1 bascula. Només cal unir J i K i portar-hi T.

d) Cada biestable T es transforma en un D amb una porta XOR (D = T ⊕ Q); com que T = 1, $D = \overline{Q}$. Si el biestable D només té la sortida Q, cal un inversor per biestable (4 en total). Si també té la sortida $\overline{Q}$, n'hi ha prou amb connectar-la a la seva pròpia entrada D: no cal cap porta. En tots dos casos, cada biestable rep com a rellotge la sortida de l'anterior.

a) Amb $(\overline{S}, \overline{R}) = (1, 0)$ el latch es posa a 0: Q = 0.

b) Pas a pas, (1, 0) → Q = 0
(1, 1) → Q = 0
(0, 1) → Q = 1
(1, 1) → Q = 1
(0, 1) → Q = 1
(1, 1) → Q = 1
(0, 1) → Q = 1
En arribar la primera vegada a A (0, 1), Q passa a 1 i els rebots posteriors, que només fan (1, 1) i (0, 1) de manera alterna, no el canvien: (1, 1) manté i (0, 1) torna a posar a 1.

c) (1, 1) → Q = 1
(1, 0) → Q = 0
(1, 1) → Q = 0
(1, 0) → Q = 0
(1, 1) → Q = 0
(1, 0) → Q = 0
Amb el primer contacte amb B, (1, 0), Q passa a 0 i es queda a 0 malgrat els rebots.

d) El senyal brut de A baixa a 0 3 vegades, però Q només té un flanc de pujada. Un comptador connectat directament al contacte comptaria 3 polsos per una sola pulsació; amb el latch compta 1. Per això es fa servir aquest circuit com a antirebot.

a) Amb LD = 1: $D_{i} = I_{i}$, i el registre carrega les dades d'entrada en el flanc. Amb LD = 0: $D_{i} = Q_{i}$, i cada biestable recarrega el seu propi valor, de manera que el registre manté el contingut.

b) Flanc 1: LD = 1, I = 1100 → Q = 1100
Flanc 2: LD = 0, I = 0011 → Q = 1100
Flanc 3: LD = 1, I = 1010 → Q = 1010
Flanc 4: LD = 0, I = 1111 → Q = 1010
Flanc 5: LD = 1, I = 0001 → Q = 0001

c) Un multiplexor de 2 a 1 per bit (LD fa de selecció: tria I_i o Q_i).

d) Retardar o tallar el rellotge amb portes crea petits desfasaments i possibles pulsos paràsits (glitches) que poden provocar canvis d'estat no desitjats; és preferible que tots els biestables rebin el mateix rellotge i que sigui l'entrada D la que decideixi si l'estat canvia (disseny síncron).

a) Taula: PARELL, X = 0 → PARELL; PARELL, X = 1 → IMPARELL; IMPARELL, X = 0 → IMPARELL; IMPARELL, X = 1 → PARELL. Sortida: Z = 0 en PARELL, Z = 1 en IMPARELL.

b) Flanc 1: X = 1 → estat IMPARELL, Z = 1
Flanc 2: X = 0 → estat IMPARELL, Z = 1
Flanc 3: X = 1 → estat PARELL, Z = 0
Flanc 4: X = 1 → estat IMPARELL, Z = 1
Flanc 5: X = 0 → estat IMPARELL, Z = 1
Flanc 6: X = 1 → estat PARELL, Z = 0
Flanc 7: X = 1 → estat IMPARELL, Z = 1
Flanc 8: X = 1 → estat PARELL, Z = 0

c) Z val 1 quan el nombre d'uns rebuts fins ara és senar. L'entrada té 6 uns (1, 1, 1, 1, 1, 1): nombre parell, i efectivament l'estat final és PARELL (Z = 0). Aquesta màquina és la base per calcular el bit de paritat d'una transmissió.

d) Amb un biestable (dos estats). Assignant PARELL = 0 i IMPARELL = 1, l'estat següent és $Q^{+} = Q \oplus X$, de manera que serveix un biestable D amb $D = Q \oplus X$ (o un biestable T amb T = X), i la sortida és $Z = Q$.

a) Flanc 1: X = 0 → S0, Z = 0
Flanc 2: X = 1 → S1, Z = 0
Flanc 3: X = 1 → S2, Z = 0
Flanc 4: X = 0 → S0, Z = 1
Flanc 5: X = 1 → S1, Z = 0
Flanc 6: X = 1 → S2, Z = 0
Flanc 7: X = 1 → S2, Z = 0
Flanc 8: X = 0 → S0, Z = 1
Flanc 9: X = 1 → S1, Z = 0
Flanc 10: X = 1 → S2, Z = 0
Flanc 11: X = 0 → S0, Z = 1
Flanc 12: X = 0 → S0, Z = 0

b) Z = 1 només es produeix des de S2 amb X = 0, és a dir, quan s'han rebut dos uns seguits i després un zero: la màquina detecta la seqüència 110. Ho fa 3 vegades (flancs 4, 8 i 11).

c) Amb 2 biestables ($2^{2}$ = 4 ≥ 3 estats). En una màquina de Mealy la sortida depèn de l'estat i de l'entrada actual, de manera que pot canviar tan bon punt canvia X, sense esperar el flanc; en una de Moore la sortida depèn només de l'estat i canvia només amb el rellotge.

a) Substituint a les equacions:
X = 0: $D_{1} = Q_{1}$ i $D_{0} = Q_{0}$, de manera que l'estat es manté en els 4 casos (00, 01, 11 i 10).
X = 1: $D_{1} = Q_{0}$, $D_{0} = \overline{Q_{1}}$: 00 → 01; 01 → 11; 11 → 10; 10 → 00.

b) Amb X = 0 el circuit manté l'estat (X fa de senyal d'habilitació); amb X = 1 recorre la seqüència 00 → 01 → 11 → 10 → 00 …, que és el codi Gray de 2 bits (canvia un sol bit a cada pas). És un comptador Gray de mòdul 4 amb habilitació.

c) 01, 11, 11, 10, 00, 01, 01, 11.

d) En el codi Gray només canvia un bit entre dos valors consecutius; amb el binari natural, en passar de 01 a 10 canvien dos bits alhora i, si un sensor els llegeix amb un petit decalatge, es pot llegir un valor intermedi erroni (00 o 11). Per això s'utilitza en codificadors de posició.

a) Cada biestable canvia 15 ns després que el seu rellotge (la sortida de l'anterior) baixi:
t = 0: flanc extern. t = 15 ns: Q₀ passa de 1 a 0 → 0110. t = 30 ns: Q₁ passa de 1 a 0 (Q₀ ha baixat) → 0100. t = 45 ns: Q₂ passa de 1 a 0 → 0000. t = 60 ns: Q₃ passa de 0 a 1 (Q₂ ha baixat) → 1000.
Es produeixen tres estats intermedis incorrectes (0110, 0100 i 0000) de 15 ns cadascun.

b) El pitjor cas és la transició amb canvi en tots els bits (de 0111 a 1000 o de 1111 a 0000): 4 · 15 ns = 60 ns. El període del rellotge ha de ser almenys 60 ns, de manera que f_màx = 1/(60·10^-9 s) = 16,7 MHz. Per a 8 bits: 8 · 15 = 120 ns i f_màx = 8,3 MHz.

c) El camí crític és el rellotge → biestable → AND → entrada del biestable següent: T_mín = 15 + 10 = 25 ns, f_màx = 40 MHz.

d) El síncron és 2,4 vegades més ràpid amb 4 bits, i la diferència creix quan augmenta el nombre de bits perquè el retard del comptador asíncron és proporcional al nombre de biestables, mentre que el del síncron gairebé no depèn de n (només augmenta lleugerament amb la mida de la porta AND). A canvi, el síncron necessita més portes. A més, en el síncron no hi ha estats intermedis falsos.

a) Les transicions són 000 → 001, 001 → 010, 010 → 011, 011 → 100 i 100 → 000. Per tant, el valor que ha de tenir cada entrada D és el del bit corresponent de l'estat següent.

b) D₂ val 1 només quan l'estat següent és 100, és a dir, en 011 (Q₁Q₀ = 11): $D_{2} = Q_{1}\cdot Q_{0}$.
D₁ val 1 quan l'estat següent és 010 o 011, o sigui des de 001 i 010: $D_{1} = Q_{1}\oplus Q_{0}$ (val 0 en 000, 011 i 100, com cal).
D₀ val 1 quan l'estat següent és 001 o 011, o sigui des de 000 i 010: s'observa que passa quan Q₀ = 0 i Q₂ = 0, de manera que $D_{0} = \overline{Q_{2}}\cdot\overline{Q_{0}}$.

c) Amb les equacions: 101 → D₂ = 0, D₁ = 1, D₀ = 0 → 010; 110 → D₂ = 0, D₁ = 1, D₀ = 0 → 010; 111 → D₂ = 1, D₁ = 0, D₀ = 0 → 100. Tots tornen a la seqüència en un sol flanc: el comptador és autocorrector.

d) Q₂ val 1 només en un dels cinc estats, de manera que té una freqüència de 1 kHz / 5 = 200 Hz i un cicle de treball del 20 % (un flanc de cada cinc).

a) Taula (estat, X → següent / Z):
S0, 0 → S0 / 0; S0, 1 → S1 / 0.
S1, 0 → S2 / 0; S1, 1 → S1 / 0 (el nou 1 pot ser l'inici d'una nova seqüència).
S2, 0 → S0 / 0; S2, 1 → S1 / 1 (seqüència 101 detectada; l'últim 1 pot ser l'inici d'una altra seqüència).

b) Codificació Q₁Q₀. L'estat següent és S1 (01) sempre que X = 1: $D_{0} = X$. L'estat següent és S2 (10) només des de S1 (Q₀ = 1) amb X = 0: $D_{1} = Q_{0}\cdot\overline{X}$. La sortida val 1 en S2 amb X = 1: $Z = Q_{1}\cdot X$.
Comprovació de totes les files amb aquestes equacions: S0,0: D₁ = 0, D₀ = 0 → 00; S0,1: 01; S1,0: D₁ = 1, D₀ = 0 → 10; S1,1: D₁ = 0, D₀ = 1 → 01; S2,0: 00; S2,1: 01 i Z = 1. Coincideixen amb la taula.

c) Flanc 1: X = 1 → Q₁Q₀ = 01, Z = 0
Flanc 2: X = 0 → Q₁Q₀ = 10, Z = 0
Flanc 3: X = 1 → Q₁Q₀ = 01, Z = 1
Flanc 4: X = 0 → Q₁Q₀ = 10, Z = 0
Flanc 5: X = 1 → Q₁Q₀ = 01, Z = 1
Flanc 6: X = 1 → Q₁Q₀ = 01, Z = 0
Flanc 7: X = 0 → Q₁Q₀ = 10, Z = 0
Flanc 8: X = 1 → Q₁Q₀ = 01, Z = 1
Es detecta 3 vegades (flancs 3, 5 i 8): els dos primers casos comparteixen l'1 central (10101).

a) Per a X = 1: 00 → 01, 01 → 10, 10 → 11, 11 → 00. Per a X = 0: 00 → 11, 01 → 00, 10 → 01, 11 → 10.

b) Q₀ sempre bascula: $J_{0} = K_{0} = 1$. Q₁ bascula en els casos següents: (X = 1 i Q₀ = 1) o (X = 0 i Q₀ = 0), és a dir, quan X i Q₀ són iguals: $J_{1} = K_{1} = \overline{X\oplus Q_{0}} = X\,Q_{0} + \overline{X}\,\overline{Q_{0}}$. (En els altres casos, J₁ = K₁ = 0 i Q₁ es manté.)
Comprovació: de 10 amb X = 0: Q₀ = X = 0 → J₁ = K₁ = 1 (Q₁ bascula a 0) i Q₀ bascula a 1 → 01. Correcte.

c) Amb aquestes equacions: 01, 10, 11, 10, 01, 10. Hi ha tres ascensos (00 → 01 → 10 → 11), dos descensos (11 → 10 → 01) i un ascens final (01 → 10).

a) 1000 → 0100 → 0010 → 1001 → 1100 → 0110 → 1011 → 0101 → 1010 → 1101 → 1110 → 1111 → 0111 → 0011 → 0001 → 1000 (torna a l'inici). Recorre 15 estats diferents abans de repetir-se.

b) $2^{4}$ = 16 estats en total. No apareix 0000: si el registre hi entrés, la XOR de dues entrades 0 dona 0 i el registre quedaria bloquejat a 0000 per sempre.

c) Seqüència per $Q_{3}$ en un període: 000100110101111. Té 8 uns i 7 zeros: una seqüència pseudoaleatòria de longitud màxima, $2^{4}$ − 1 = 15.

d) El període és de 15 flancs = 15 ms. Aquests circuits generen seqüències pseudoaleatòries de manera molt econòmica (només 4 biestables i una porta XOR): s'usen per a proves de comunicacions, codis de detecció d'errors (CRC), xifratge i generació de soroll.

a) El bit de menys pes (b₀) arriba primer: del byte 10110010 = b₇…b₀ s'obté 0, 1, 0, 0, 1, 1, 0, 1.

b) Cada bit nou entra a Q₀ i empeny els anteriors, de manera que, després de 8 flancs, el primer bit rebut (b₀) és a Q₇ i l'últim (b₇) és a Q₀. Llegit com a Q₇…Q₀: 01001101, que és 4D en hexadecimal (el byte amb els bits en ordre invers). Llegit en l'ordre Q₀…Q₇, és a dir, amb Q₀ com a bit de més pes: 10110010 = B2. Cal doncs connectar Q₀ al bit de més pes del bus de sortida i Q₇ al de menys pes.

c) t_byte = 8 / 9600 = 0,833 ms. Després del vuitè flanc, el novè flanc arriba al cap d'un període de bit: 1/9600 = 104 µs; en aquest interval s'ha de llegir (o copiar a un registre de sortida) el contingut, perquè si no el bit b₀ sortiria per Q₇.

d) Si arribés primer el bit de més pes, després de 8 flancs el bit de més pes seria a Q₇, de manera que les sortides es llegirien directament com a Q₇…Q₀ sense inversió.

a) El camí més lent és t_cq,màx + t_lògica,màx + t_su = 12 + 18 + 5 = 35 ns. T_mín = 35 ns ⇒ f_màx = 1/35 ns = 28,6 MHz.

b) El camí més ràpid és t_cq,mín + t_lògica,mín = 4 + 3 = 7 ns, que ha de ser major que t_h = 2 ns: es compleix amb un marge de 5 ns. (El temps de manteniment no depèn de la freqüència: només depèn dels camins ràpids.)

c) T_mín = 12 + 8 + 5 = 25 ns ⇒ f_màx = 40 MHz. Hold: 4 + 1 = 5 ns > 2 ns: es compleix.

d) Sense lògica: T_mín = t_cq + t_su = 12 + 5 = 17 ns ⇒ f_màx = 58,8 MHz. Si el rellotge va més de pressa que 1/T_mín, el flanc arriba abans que la dada s'hagi estabilitzat a l'entrada del biestable; aquest pot capturar un valor incorrecte o entrar en un estat inestable (metaestabilitat). Per això la freqüència màxima ve donada pel camí més lent.

a) Seqüència: 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 6, 7, … (després de 15 carrega 6). Té 10 estats: mòdul 10. La freqüència a l'entrada és 10 kHz i el cicle complet té 10 flancs: 1 kHz. $Q_{3}$ val 1 en els estats 8 a 15, o sigui en 8 dels 10 estats (80 % del període).

b) Dins del cicle 0, 1, …, 11 els estats amb $Q_{3}Q$₁$Q_{0}$ = 111 són només aquells amb $Q_{3}$ = 1 (8 a 11) i $Q_{1}Q$₀ = 11: l'únic és el 1011 (11 en decimal). Per tant, LD = $Q_{3}Q$₁$Q_{0}$ val 1 només en 1011 i no cal $Q_{2}$ (1111 no és al cicle). Seqüència: 0, 1, …, 11, 0, 1, …: mòdul 12.

c) Amb un reset asíncron a 1100, el comptador arriba realment a 1100 durant un instant breu i després es reinicia: aquest estat intermedi no hauria d'existir, i pot generar pulsos paràsits a les sortides. Amb la càrrega síncrona, els estats són sempre els de la seqüència (11 passa directament a 0 en el flanc), no hi ha estats transitoris i es pot carregar qualsevol valor inicial, no només zero, per aconseguir comptadors de qualsevol interval.

a) Bits de A (de menys pes a més pes): 1, 1, 0, 1; de B: 0, 1, 1, 0.
Cicle 1: A = 1, B = 0, C = 0 → S = 1, C⁺ = 0
Cicle 2: A = 1, B = 1, C = 0 → S = 0, C⁺ = 1
Cicle 3: A = 0, B = 1, C = 1 → S = 0, C⁺ = 1
Cicle 4: A = 1, B = 0, C = 1 → S = 0, C⁺ = 1
Cicle 5: A = 0, B = 0, C = 1 → S = 1, C⁺ = 0

b) Els bits de S, de menys pes a més pes, són 1, 0, 0, 0, 1, o sigui, 10001 = 17 = 11 + 6. Comprovat.

c) El cinquè cicle serveix per afegir el transport final que queda al biestable després del quart bit (aquí C = 1, que dona el bit de més pes del resultat). Amb A = B = 15 (1111), el resultat (30 = 11110) també necessita 5 bits, de manera que cal el mateix cinquè cicle; i, en general, per sumar dos nombres de n bits calen n + 1 cicles. A més, el biestable de transport s'ha de posar a zero abans de cada suma; si es comencés amb C = 1, el resultat tindria una unitat de més.

d) 5 cicles a 1 MHz = 5 µs. Un sumador paral·lel de 4 bits fa la suma en un sol cicle (després de la propagació del transport) però necessita 4 sumadors complets; el sumador en sèrie n'usa només 1 més un biestable, a costa d'un temps n + 1 vegades més llarg. És un exemple típic de compromís entre velocitat i maquinari.

a) 32 768 = 2¹⁵, de manera que calen 15 biestables T (o divisors per 2) en cadena. A la sortida del desè: 32 768 / 2¹⁰ = 32 Hz.

b) Segons: unitats (4) + desenes de 0 a 5 (3 biestables, perquè 5 = 101) = 7. Minuts: igual, 7. Hores: unitats (4) + desenes de 0 a 2 (2 biestables) = 6. Total dels comptadors: 7 + 7 + 6 = 20 biestables; amb el divisor de freqüència: 35 biestables.

c) En binari natural: 6 + 6 + 5 = 17 biestables, 3 menys. Tot i així, el BCD és preferible perquè cada xifra es pot convertir directament en un visualitzador de 7 segments amb un descodificador BCD; amb el binari natural caldria una conversió binari-decimal complexa per mostrar les hores, els minuts i els segons.

d) El 6 és 110. Els únics estats de la seqüència (0–5) amb Q₂Q₁ = 11 serien el 6 i el 7; com que el 7 no es dona mai, n'hi ha prou amb detectar $Q_{2}\cdot Q_{1}$: quan val 1, s'activa el reset (síncron o asíncron) del comptador de desenes.

e) Cada 24 h = 86 400 s = 86 400 flancs d'1 Hz.

a) OBRINT és 01 i TANCANT és 11: $\mathrm{MO} = \overline{Q_{1}}\cdot Q_{0}$ i $\mathrm{MT} = Q_{1}\cdot Q_{0}$.

b) D₁ val 1 quan l'estat següent és 10 o 11, és a dir: des d'OBRINT (01) amb FCO = 1 (→ 10); des d'OBERT (10), tant si P = 0 (→ 10) com si P = 1 (→ 11); i des de TANCANT (11) amb FCT = 0 (→ 11):
$D_{1} = \overline{Q_{1}}\,Q_{0}\,\mathrm{FCO} + Q_{1}\,\overline{Q_{0}} + Q_{1}\,Q_{0}\,\overline{\mathrm{FCT}}$.
D₀ val 1 quan l'estat següent és 01 o 11: des de TANCAT (00) amb P = 1 (→ 01); des d'OBRINT (01) amb FCO = 0 (→ 01); des d'OBERT (10) amb P = 1 (→ 11); i des de TANCANT (11) amb FCT = 0 (→ 11):
$D_{0} = \overline{Q_{0}}\,P + Q_{0}\,\left(\overline{Q_{1}}\,\overline{\mathrm{FCO}} + Q_{1}\,\overline{\mathrm{FCT}}\right)$.
(S'ha comprovat amb les 32 combinacions d'estat i entrades que aquestes equacions reprodueixen la taula de transicions.)

c) Flanc 1: P = 1, FCO = 0, FCT = 1 → 01 (OBRINT)
Flanc 2: P = 0, FCO = 0, FCT = 0 → 01 (OBRINT)
Flanc 3: P = 0, FCO = 0, FCT = 0 → 01 (OBRINT)
Flanc 4: P = 0, FCO = 1, FCT = 0 → 10 (OBERT)
Flanc 5: P = 0, FCO = 0, FCT = 0 → 10 (OBERT)
Flanc 6: P = 1, FCO = 0, FCT = 0 → 11 (TANCANT)
Flanc 7: P = 1, FCO = 0, FCT = 0 → 11 (TANCANT)
Flanc 8: P = 0, FCO = 0, FCT = 1 → 00 (TANCAT)
El portal s'obre (flancs 1–3), arriba a obert (4), espera (5), es tanca quan es prem P (6–7; la segona pulsació s'ignora) i queda tancat quan FCT = 1 (8).

d) Mentre es tanca, el sistema ignora el polsador i no té cap sensor d'obstacles: si algú es posa al mig, el portal no s'aturaria ni tornaria a obrir-se. S'hauria d'afegir una entrada de fotocèl·lula (OBS) que, si val 1 en l'estat TANCANT, enviï la màquina a OBRINT. També es podria afegir un temporitzador de seguretat perquè el motor s'aturi si no arriba cap final de cursa.

a) Mealy. Els estats són el prefix de $1101$ ja rebut: $S_0$ = res (o un prefix inútil), $S_1$ = «1», $S_2$ = «11», $S_3$ = «110». La taula és:

Justificació: des de $S_1$ («1») un $0$ dona «10», que no és prefix, i es torna a $S_0$. Des de $S_2$ («11»), un altre $1$ dona «111», el final del qual («11») segueix sent prefix: es queda a $S_2$. Des de $S_3$ («110»), un $1$ completa la seqüència ($Z=1$) i el seu últim bit, «1», és ja un prefix: es passa a $S_1$ (així s'admet el solapament); un $0$ dona «1100», que no té cap prefix com a final: $S_0$.

b) Moore. Cal un estat més, $E_4$ = «1101 acabat de detectar», amb $Z=1$:

Necessita 5 estats perquè la sortida és una propietat de l'estat: la informació «acabo de detectar» no es pot guardar a la transició de $S_3$ a $S_1$ (com fa Mealy), de manera que s'ha de reflectir en un estat propi. Quant a transicions, $E_4$ es comporta com $E_1$ (el seu últim bit és un $1$ i no hi ha cap altre prefix): $E_4\to E_0$ amb $0$ i $E_4\to E_2$ amb $1$.

c) Entrada $X = 0110110101101$. $S_k$ és l'estat de Mealy abans del flanc $k$ (la sortida $Z$ de Mealy es veu durant el cicle $k$, amb $X_k$ a l'entrada); $E_k$ és l'estat de Moore després del flanc $k$ (la seva sortida es veu durant el cicle $k+1$).

Es detecta la seqüència en els flancs 5, 8, 13. Mealy dona el pols en el mateix cicle en què arriba l'últim bit; Moore, un cicle més tard (després del flanc).

d) Mealy: 4 estats → $\lceil\log_2 4\rceil = 2$ biestables. Moore: 5 estats → $\lceil\log_2 5\rceil = 3$ biestables. Avantatges de Mealy: menys estats i resposta immediata (el mateix cicle). Inconvenients: la sortida depèn de l'entrada, i si l'entrada té soroll o és asíncrona, la sortida pot tenir pics (glitches); a més, el camí combinacional entre l'entrada i la sortida limita la velocitat màxima. Avantatges de Moore: sortida estable durant tot el cicle (només canvia amb el rellotge) i fàcil de sincronitzar; inconvenients: més estats i una sortida endarrerida un cicle. Sense solapament, un cop detectada la seqüència cal «començar de nou»: a Mealy $S_3\xrightarrow{1}S_0$ amb $Z=1$, i a Moore $E_4$ es comporta com $E_0$. A la seqüència de l'apartat c) hi ha 3 deteccions amb solapament i 2 sense; a $X = 1101101$ n'hi ha 2 amb solapament i 1 sense.

Errors típics

• Tornar a $S_0$ des de $S_3$ quan arriba un $1$ en lloc de passar a $S_1$: es perd el solapament.
• Posar $S_2\xrightarrow{1}S_1$ (o $S_0$) en lloc de quedar-se a $S_2$: «111» acaba en «11», que segueix sent prefix.
• Llegir la sortida de Moore en el mateix cicle que arriba l'últim bit: apareix un cicle més tard.
• Comptar els biestables com el nombre d'estats i no com $\lceil\log_2 n\rceil$.

Conceptes treballats: diagrama d'estats, màquines de Mealy i de Moore, detecció de seqüències amb solapament, codificació d'estats, comparació de models, temporització de la sortida.

a) 6 estats → $\lceil\log_2 6\rceil = 3$ biestables. Particions. Partició inicial per la sortida: $G_1=\{A,B,D\}$ ($Z=0$) i $G_2=\{C,E,F\}$ ($Z=1$). Refinament 1: els grups dels estats següents (amb $X=0$ i amb $X=1$) són: $A\to(G_1,G_2)$, $B\to(G_1,G_1)$, $D\to(G_1,G_1)$; $C\to(G_2,G_1)$, $E\to(G_2,G_1)$, $F\to(G_2,G_1)$. Per tant, $A$ es separa de $B$ i $D$: queden $\{A\}$, $\{B,D\}$, $\{C,E,F\}$. Refinament 2: amb les tres classes, $B\to(\{A\},\{B,D\})$ i $D\to(\{A\},\{B,D\})$ (iguals); $C$, $E$ i $F\to(\{C,E,F\},\{A\})$ (iguals): la partició ja no canvia. Estats equivalents: $B\equiv D$ i $C\equiv E\equiv F$.

b) Reduïda ($P=\{A\}$, $Q=\{B,D\}$, $R=\{C,E,F\}$):

Té 3 estats i necessita $\lceil\log_2 3\rceil = 2$ biestables: s'estalvia un biestable i la lògica combinacional és més senzilla.

c) Argument per inducció: $B$ i $D$ tenen la mateixa sortida ($Z=0$) i, amb cada valor de $X$, van a estats de la mateixa classe (amb $X=0$, tots dos a $A$; amb $X=1$, $B\to D$ i $D\to B$). Igualment, $C$, $E$ i $F$ tenen $Z=1$, amb $X=0$ van a $\{C,E,F\}$ i amb $X=1$ van a $A$. Per tant, després de cada bit d'entrada, dos estats de la mateixa classe continuen en una mateixa classe i donen la mateixa sortida: no es poden distingir amb cap seqüència, de cap longitud. Seqüència distingidora mínima per a $A$ i $B$: 1 (longitud 1): des de $A$ amb $X=1$ es va a $C$ ($Z=1$) i des de $B$ a $D$ ($Z=0$). $B$ i $C$ ja es distingeixen sense cap entrada, perquè tenen sortides diferents.

d) Sortides (després de cada flanc) des de $A$ / $P$ amb $X = 10110010$: original 11011100; reduïda 11011100: idèntiques. Reduir abans de dissenyar estalvia biestables i portes, redueix el consum i el risc d'error i facilita la verificació. Si féssim equivalents dos estats que no ho són (per exemple $A$ i $B$), la màquina resultant donaria sortides incorrectes per a la seqüència que els distingeix (1).

Errors típics

• Considerar equivalents dos estats només perquè tenen la mateixa sortida, sense mirar els estats següents.
• Parar el refinament després d'una sola passada: cal repetir fins que cap grup es parteixi.
• Mirar només els estats següents amb $X=0$ i oblidar $X=1$.
• Pensar que l'estat inicial es pot perdre en la fusió: la màquina reduïda ha de contenir la classe de l'estat inicial.

Conceptes treballats: minimització d'estats, equivalència d'estats, particions successives, màquina de Moore, nombre de biestables, verificació per seqüències.

a)

Dos estats: $Q=0$ = «encara no s'ha rebut cap 1» (no s'ha trobat el primer 1); $Q=1$ = «ja s'ha trobat un 1». Diagrama (entrada/sortida): $0\xrightarrow{0/0}0$, $0\xrightarrow{1/1}1$, $1\xrightarrow{0/1}1$, $1\xrightarrow{1/0}1$. Una vegada a $Q=1$, el circuit no en surt (fins al reinici).

b) Mentre $Q=0$, $Z=X$ (es copien els bits, i el primer 1 també, perquè $Z=1\oplus 0=1$); un cop $Q=1$, $Z=\overline{X}$ (s'inverteixen). Resultats (escrits amb el bit de menys pes a la dreta): 108 = 01101100 → 10010100 = 148 = 256 − 108; 1 = 00000001 → 11111111 = 255 = 256 − 1; 128 = 10000000 → 10000000 (cas límit: $10000000$ és −128 en complement a 2 de 8 bits i el seu oposat, +128, no es pot representar; el resultat torna a ser el mateix: desbordament). Per al zero: 00000000. El circuit calcula el complement a 2, és a dir, el nombre oposat: $-N \equiv 256-N$. Demostració: $-N = \overline{N}+1$, i la suma de 1 propaga un transport des dels bits de menys pes: els zeros finals de $N$ es converteixen en uns i passen a zero amb el transport, fins al primer 1, que passa a 0 i atura el transport. Per tant, els bits fins al primer 1 (inclòs) es mantenen i la resta s'inverteix, exactament el que fa el circuit.

c) Sense reiniciar, la primera paraula (108) deixa $Q=1$, de manera que la segona (20) s'inicia amb $Q=1$ i s'inverteix tota: la sortida és 11101011 = 235, el complement a 1 de 20 ($255-20$), no el seu complement a 2 (que seria 11101100). El reinici és, per tant, imprescindible entre paraules.

d) El circuit seqüencial usa un biestable i dues portes (OR i XOR), però necessita 8 cicles de rellotge per paraula (una sola entrada en sèrie). La versió combinacional necessita 8 inversors i un incrementador de 8 bits (una cadena de 8 semisumadors, és a dir, uns 8 XOR i 8 AND), però dona el resultat en un sol cicle, amb un retard igual al del transport. Amb moltes paraules o amb amplades grans (per exemple, 64 bits), el seqüencial manté el cost constant i només creix en temps ($n$ cicles); el combinacional creix en maquinari. Es tria segons si prima l'àrea o la velocitat.

Errors típics

• Posar $Z=X$ quan $Q=1$ o invertir ja el primer bit $1$: el primer 1 es copia, no s'inverteix.
• No reiniciar el biestable entre paraules: s'obté el complement a 1 en lloc del complement a 2.
• Introduir els bits començant pel de més pes: el circuit només funciona amb el bit de menys pes primer.
• Pensar que el circuit pot canviar el signe de −128 a +128: en 8 bits +128 no és representable.

Conceptes treballats: màquines de Mealy d'un biestable, aritmètica de complement a 2, càlcul en sèrie, funcions XOR/OR, reinici asíncron, compromís àrea–temps.

a) Amb $D_0=Q_3$, el circuit només gira els bits i el nombre d'uns no canvia. Els 16 estats formen 6 cicles: $\{0000\}$ (1), $\{1111\}$ (1), $\{1010,0101\}$ (2), i tres cicles de longitud 4: $\{1000,0100,0010,0001\}$ (el correcte), $\{1100,0110,0011,1001\}$ i $\{1110,0111,1011,1101\}$. Només un cicle és correcte. Si arrenca a $0110$, cicla indefinidament $0110\to0011\to1001\to1100\to\ldots$ i mai no arriba al correcte: tindrem dues llums enceses.

b) Perquè l'error és permanent: un soroll o un arrencament en un estat incorrecte deixa el sistema bloquejat en un cicle invàlid. Una solució sense portes seria posar un preset/reset asíncron al connectar l'alimentació (força $1000$); però només corregeix l'arrencament, no pertorbacions posteriors, i necessita un circuit de reinici fiable.

c) Amb $D_0=\overline{Q_0+Q_1+Q_2}$: quan hi ha una unitat en $Q_0$,$Q_1$ o $Q_2$, $D_0=0$ i el bit es limita a desplaçar-se; només quan els tres primers són 0, $D_0=1$. Seqüència correcta: 1000 → 0100 → 0010 → 0001 → 1000 (no canvia: a $0001$, $D_0=1$ i torna a $1000$). Des de $0000$: $0000\to1000$. Des de $1111$: 1111 → 0111 → 0011 → 0001. Altres exemples: 0101 → 0010; 1100 → 0110 → 0011 → 0001; 0111 → 0011 → 0001. L'anell té ara un sol cicle (de longitud 4) i els altres 12 estats són transitoris: el pitjor cas (estats 1100, 1101, 1110, 1111) triga 3 cicles de rellotge.

d) Sí: una pertorbació (un bit que commuta per un pic de tensió, radiació, etc.) pot dur el sistema a qualsevol dels 16 estats, també a $1111$ o $0101$. Amb l'anell lliure quedaria bloquejat; amb la versió autocorrectora, torna a la seqüència correcta en com a màxim 3 cicles. Per a 8 llums: 8 biestables (256 estats, 8 de correctes); la mateixa idea, $D_0=\overline{Q_0+Q_1+\dots+Q_6}$ (NOR de 7 entrades), els corregeix en com a màxim 7 cicles. Un anell de 4 llums gasta 4 biestables per a 4 estats; un comptador binari de 2 bits en té prou amb 2 (més un descodificador de 2 a 4). L'anell no necessita descodificador i les seves sortides no tenen glitches, però gasta més biestables.

Errors típics

• Creure que un anell lliure sempre arrenca bé: segons l'estat inicial pot quedar bloquejat en un cicle invàlid.
• Fer el NOR dels quatre bits en lloc dels tres primers: l'estat $0000$ passa a formar part de la seqüència i l'anell tindria 5 estats.
• Comptar només un estat «incorrecte»: n'hi ha 12 (16 − 4), repartits en cicles invàlids o en transitoris.
• Oblidar que l'autocorrecció no impedeix que durant uns cicles hi hagi encesa de més d'una llum.

Conceptes treballats: comptadors en anell, cicles d'estats, estats invàlids i autocorrecció, robustesa davant de pertorbacions, realimentació, comparació amb comptador binari.

a) Si l'entrada canvia just al voltant del flanc, el primer biestable pot quedar en un estat intermedi (metaestable) durant un temps aleatori, i la sortida pot arribar a la lògica següent en un nivell indeterminat. El segon biestable dona un cicle sencer perquè $Q_1$ es resolgui abans de ser capturat: així la probabilitat d'error baixa de manera exponencial amb el temps disponible. Amb $Q_2$ i $Q_3$ es forma un detector de flanc de pujada: $P=1$ durant un cicle quan $Q_2$ acaba de passar a 1 i $Q_3$ encara és 0.

b) Entrada 00101101111111010000000000:

El pols $P$ es produeix 4 vegades. Hi ha tres polsos en prémer (flancs 4, 6 i 9) i un en deixar de prémer (flanc 17), tot i que només hi ha hagut una pulsació: el sincronitzador copia fidelment els rebots, i cada pujada de la seqüència mostrejada (0→1) genera un pols. Mostrejar a 1 kHz no n'elimina cap, perquè el rebot dura 3 períodes.

c) El filtre només dona $Y=1$ quan han passat 4 flancs seguits amb $S=1$ (flancs 8–11); passa a $Y=1$ al flanc 11 i no es modifica pels rebots curts (fins a 3 flancs de duració). Es posa a 0 al flanc 20, després de 4 zeros seguits al final. Resultat: un sol pols a $Y$ (columna final). S'ha escollit $N=4$ perquè el rebot de 3 ms ocupa com a màxim 3 mostres: amb $N=4$ el filtre exigeix més temps que la durada del rebot.

d) Retard: dos flancs del sincronitzador (2 ms) més 4 flancs del filtre = uns 6 ms (més fins a 1 ms perquè la pulsació no és síncrona amb el rellotge), que un usuari no nota. Si el rebot durés 8 ms, el filtre amb $N=4$ podria donar-se per acabat abans d'hora i generar polsos falsos: caldria $N\geq 9$ (9 ms). Pel que fa a biestables: el comptador ha de comptar de 0 a 4 (5 valors → 3 biestables) i cal un biestable més per a $Y$: 4 en total.

Errors típics

• Connectar el polsador directament a la lògica síncrona sense sincronitzador: risc de metaestabilitat.
• Pensar que el sincronitzador elimina el rebot: només alinea el senyal amb el rellotge.
• Triar $N$ més petit que la durada del rebot expressada en períodes de mostreig.
• Generar el pols amb $Q_1$ i $Q_2$ en lloc de $Q_2$ i $Q_3$: el senyal $Q_1$ encara pot ser metaestable.

Conceptes treballats: metaestabilitat i sincronització, detector de flanc, rebots, filtre digital amb comptador, freqüència de mostreig, compromís entre robustesa i latència.

a) Taula (la seqüència té 8 estats: no hi ha estats no utilitzats, tots els codis binaris de 3 bits apareixen):

Mapes de Karnaugh: $D_2=Q_2Q_0+Q_1\overline{Q_0}$, $D_1=\overline{Q_2}Q_0+Q_1\overline{Q_0}$ i $D_0=Q_2Q_1+\overline{Q_2}\,\overline{Q_1}=\overline{Q_2\oplus Q_1}$ (és a dir, $D_0$ val 1 quan $Q_2$ i $Q_1$ són iguals).

b) Comprovació: de $001$ → $D_2=0\cdot1+0=0$, $D_1=\overline{0}\cdot1+0=1$, $D_0=\overline{0\oplus0}=1$ → $011$ ✓; de $110$ → $D_2=0+1\cdot1=1$, $D_1=0+1\cdot1=1$, $D_0=\overline{1\oplus1}=1$ → $111$ ✓; de $100$ → $D_2=0+0=0$, $D_1=0+0=0$, $D_0=\overline{1\oplus0}=0$ → $000$ ✓. (S'han comprovat els vuit estats per ordinador.) Cost aproximat: $D_2$: 2 AND + 1 OR + 1 inversor; $D_1$: igual; $D_0$: 1 XNOR. Unes 8–9 portes de dues entrades i uns 3 inversors en total.

c) En Gray cada transició canvia exactament 1 bit: 8 commutacions per cicle. En binari natural: 1 + 2 + 1 + 3 + 1 + 2 + 1 + 3 = 14 commutacions. Si el consum dinàmic és proporcional a les commutacions, el Gray fa servir 8/14 = 0,57 del consum, és a dir, un estalvi del 43 % (pel que fa a les sortides del comptador; la lògica de realimentació també commuta).

d) En binari, de $011$ a $100$ canvien els tres bits; si els biestables o els cables no són perfectament simultanis, durant un instant el sensor pot veure combinacions intermèdies com $111$, $101$ o $000$, que són posicions molt diferents (error de fins a mig recorregut). En Gray, de $010$ a $110$ (per exemple) només canvia un bit: en el pitjor cas el sensor llegeix l'estat anterior o el posterior, és a dir, un error d'un sol pas. Per això els codificadors de posició absoluta fan servir el codi Gray.

Errors típics

• Dissenyar un comptador binari i convertir-lo a Gray a la sortida: dona la mateixa seqüència, però els biestables continuen commutant com en binari i no s'estalvia consum.
• Obtenir $D_0$ amb una funció de $Q_0$: en aquest codi depèn de $Q_2$ i $Q_1$.
• Considerar que el Gray elimina del tot l'error: l'error es redueix a un pas, no desapareix.
• Comptar en binari les commutacions del pas 111 → 000 com a una sola: en realitat canvien tres bits.

Conceptes treballats: comptadors síncrons, codi Gray, taula de transicions, simplificació amb mapes de Karnaugh, consum dinàmic per commutacions, errors de lectura asíncrona.

a) Estats: $S_0$ (0 ct), $S_1$ (10 ct), $S_2$ (20 ct); els imports de 30 o 40 ct no necessiten estat perquè en aquest moment s'emet $P$ (i $R$) i es torna a $S_0$. Taula (entrada $A,B$ → estat següent / $P\,R$):

Observa que $S_1+10=20$ (va a $S_2$), $S_1+20=30$ (producte), $S_2+10=30$ (producte) i $S_2+20=40$ (producte i devolució).

b) Mapes de Karnaugh amb indiferents ($Q_1Q_0=11$ i $A=B=1$):
$D_1 = A\,Q_0 + B\,\overline{Q_1}\,\overline{Q_0} + Q_1\,\overline{A}\,\overline{B}$
$D_0 = A\,\overline{Q_1}\,\overline{Q_0} + Q_0\,\overline{A}\,\overline{B}$
$P = A\,Q_1 + B\,Q_0 + B\,Q_1$
$R = B\,Q_1$
(Comprovades per ordinador per a les 3 × 3 = 9 situacions vàlides.)

c)

Total cobrat: 130 ct; productes: 4 (120 ct), devolucions: 1 (10 ct) i import pendent: 0 ct → 130 = 130 ✓.

d) Amb $A=B=1$ les equacions donen, per exemple: des de $S_0$: $D_1D_0=11$, $P=0$, $R=0$; des de $S_1$: $D_1D_0=10$, $P=1$, $R=0$; des de $S_2$: $D_1D_0=00$, $P=1$, $R=1$. Són comportaments no especificats: des de $S_0$ amb $A=B=1$ la màquina va a l'estat no utilitzat $11$, i des de $S_1$ o $S_2$ lliura producte (i fins i tot devolució) amb un import que potser no s'ha pagat. Des de l'estat $11$: amb $AB=00$ es queda a $11$ ($D_1D_0=11$, $P=0$, $R=0$), és a dir, queda bloquejada mentre no arribi cap moneda; amb $AB=10$: $D_1D_0=10$, $P=1$, $R=0$; amb $AB=01$: $D_1D_0=00$, $P=1$, $R=1$. En aquests dos casos lliura producte sense cobrar-lo. Les indiferents només són defensables si les situacions són físicament impossibles (així s'estalvien portes), però aquest disseny no és autocorrector: cal un reinici en connectar l'alimentació, o bé especificar totes les transicions de $11$ cap a $S_0$ amb $P=R=0$ (unes portes més). Una alternativa més robusta és la codificació one-hot (3 biestables, un per estat) amb totes les combinacions no vàlides dirigides a $S_0$ sense lliurar res.