SIMULADO P2 – SISTEMAS DIGITAIS – GABARITO

1-
Primeiro, construímos a tabela-verdade de cada uma das saídas 𝑍:

𝑥 𝑦 𝐽 = 𝑥̅ 𝐾=𝑦 𝐶 𝑞 𝑍1 = 𝑞̅
0 0 1 0 ↑ 1 0
0 1 1 1 ↑ 𝑞̅ 𝑞
1 0 0 0 ↑ 𝑞 𝑞̅
1 1 0 1 ↑ 0 1

𝑥 𝑦 𝐽 = 𝑥̅ 𝐾 = 𝑦̅ 𝐶̅ 𝑞 𝑍2 = 𝑞
0 0 1 1 ↓ 𝑞̅ 𝑞̅
0 1 1 0 ↓ 1 1
1 0 0 1 ↓ 0 0
1 1 0 0 ↓ 𝑞 𝑞

Por fim, o diagrama temporal das saídas pode ser escrito.

2-a)

Em um contador de módulo 7 teremos 22 < 7 < 23 ⟹ log 2 23 = 3 flip-flops.

Assim, de 8 estados possíveis para 3 FF’s, teremos 7 “permanentes” e um “temporário”.
2-b)
De acordo com o diagrama de estados, o contador deve passar do estado 110
para o 000 com uma brevíssima parada no 111. Essa transição pode ser implementada
̅̅̅̅̅̅ dos FF’s quando
com uma porta NAND que envia um sinal baixo para as entradas 𝐶𝐿𝑅
o estado 111 é atingido.

2-c)
Por fim, podemos escrever as formas de onda do contador:

Neste caso, os três FF’s iniciam a operação com 𝑄 = 0, com o FF do dígito 𝐴

sendo permanentemente alimentado com 𝐽 = 𝐾 = 1. Considere 𝑄(𝑡) a saída do FF no
instante atual, e 𝑄(𝑡 − 1) a saída no instante anterior.
Antes da primeira borda de descida, temos:
𝐽𝐴 = 𝐾𝐴 = 1 → 𝑄𝐴 (𝑡) = 0
𝐽𝐵 = 𝐾𝐵 = 𝑄𝐴 (𝑡 − 1) = 0 → 𝑄𝐵 (𝑡) = 0
𝐽𝐶 = 𝐾𝐶 = 𝑄𝐴 (𝑡 − 1) ∙ 𝑄𝐵 (𝑡 − 1) = 0 → 𝑄𝐶 (𝑡) = 0
Quando ocorre a primeira borda de descida:
𝐽𝐴 = 𝐾𝐴 = 1 → 𝑄𝐴 (𝑡) = 1
𝐽𝐵 = 𝐾𝐵 = 𝑄𝐴 (𝑡 − 1) = 0 → 𝑄𝐵 (𝑡) = 0
𝐽𝐶 = 𝐾𝐶 = 𝑄𝐴 (𝑡 − 1) ∙ 𝑄𝐵 (𝑡 − 1) = 0 → 𝑄𝐶 (𝑡) = 0
E assim sucessivamente, até o momento em que 𝑄𝐴 = 𝑄𝐵 = 𝑄𝐶 = 1, que é
quando a porta NAND limpa o conteúdo dos registradores, fazendo-os retornarem para
𝑄𝐴 = 𝑄𝐵 = 𝑄𝐶 = 0.
3-a)
3-b)

Primeiro, o numeral (−14)10 = (110010)𝐶2 é adicionado na memória, portanto

[𝑀] = 110010. As saídas dos registradores A e B são inicializadas com valor nulo,
portanto [𝐴] = [𝐵] = 000000. No primeiro pulso de 𝐿𝑂𝐴𝐷, os valores da memória são
carregados para 𝐴, portanto [𝑀] → [𝐴], [𝐴] = 110010. Assim, passamos a ter [𝐴] =
110010 e [𝐵] = 000000, e o resultado gerado pelo somador será [𝑆] = [𝐴] + [𝐵] =
110010, com o alarme de overflow baixo. No primeiro pulso de 𝑇𝑅𝐴𝑁𝑆𝐹𝐸𝑅, os valores
de 𝑆 são transferidos para 𝐵, portanto [𝑆] → [𝐵], [𝐵] = 110010.
Repare que, após o primeiro pulso de 𝑇𝑅𝐴𝑁𝑆𝐹𝐸𝑅, o alarme de overflow passa a
ter valor alto. Isso ocorre porque, com [𝐴] = 110010 e [𝐵] = 110010, teremos a seguinte
operação nos blocos somadores:
1 1
1 1 0 0 1 0
+ 1 1 0 0 1 0
1 1 0 0 1 0 0
O bit em verde é a saída que aparece no overflow. Como não houve um novo
pulso de 𝑇𝑅𝐴𝑁𝑆𝐹𝐸𝑅, esse resultado de [𝑆] não está sendo repassado para o registrador
𝐵.
Agora, adicionamos o numeral (−11)10 = (110101)𝐶2 na memória, portanto
[𝑀] = 110101. Neste momento, saídas dos registradores A e B estão com [𝐴] = [𝐵] =
110010. No segundo pulso de 𝐿𝑂𝐴𝐷, os valores da memória são carregados para 𝐴,
portanto [𝑀] → [𝐴], [𝐴] = 110101. Assim, passamos a ter [𝐴] = 110101 e [𝐵] = 110010,
e o resultado gerado pelo somador será [𝑆] = [𝐴] + [𝐵] = 100111, com o alarme de
overflow alto. No segundo pulso de 𝑇𝑅𝐴𝑁𝑆𝐹𝐸𝑅, os valores de 𝑆 são transferidos para
𝐵, portanto [𝑆] → [𝐵], [𝐵] = 100111, e assim o resultado da nossa soma está salvo no
registrador 𝐵.
1
1 1 0 1 0 1 → −14
+ 1 1 0 0 1 0 → −11
1 1 0 0 1 1 1 → −25
4-a)
O circuito lógico do MUX 74HC151 é implementado da seguinte forma:

Com a seguinte tabela-verdade padrão:

 Portanto, a tabela-verdade para o circuito em questão será:

C B A D Z
0 0 0 0 0
0 0 0 1 0
0 0 1 0 0
0 0 1 1 1
0 1 0 0 1
0 1 0 1 1
0 1 1 0 0
0 1 1 1 0
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 0 1 1 0
1 1 0 0 0
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0

4-b)
Construindo uma tabela-verdade para o diagrama de estados do contador:

𝐽 𝐾 𝑐𝑙𝑘 𝑄(𝑡 + 1)
0 0 ↓ 𝑄(𝑡)
0 1 ↓ 0
1 0 ↓ 1
1 1 ↓ 𝑄̅ (𝑡)

𝑄1 𝑄0 (𝑡) 𝑄1 𝑄0 (𝑡 + 1) 𝐽1 𝐾1 𝐽0 𝐾0
00 10 1X 0X
01 00 0X X1
10 01 X1 1X

Montando o mapa de Karnaugh para os J e K:

𝑄̅1 𝑄1
𝑄̅0 1 X
𝑄0 0
𝐽1 = 𝑄̅0

𝑄̅1 𝑄1
𝑄̅0 X 1
𝑄0 X
𝐾1 = 𝑄̅0

𝑄̅1 𝑄1
𝑄̅0 0 1
𝑄0 X
𝐽0 = 𝑄1 𝑄̅0
 𝑄̅1 𝑄1
𝑄̅0 X X
𝑄0 1
𝐾0 = 𝑄̅1
Construindo o contador:

Construindo a tabela-verdade:

𝑆2 𝑆1 𝑆0 D Z
0 0 0 1 0
0 1 0 1 1
0 0 1 1 0

Por fim, temos a forma de onde de Z: