7.13) Desenhe um contador decrescente síncrono de módulo 32.

Passo 1

O enunciado pede para desenhar um contador decrescente síncrono de módulo 32.
Informações relevantes fornecidas pelo enunciado (o que tenho que atender):
  • O contador deve ser decrescente (cada pulso de clock reduz o valor em 1).
  • Deve ser síncrono (todos os flip‑flops compartilham o mesmo clock e as entradas são geradas por lógica combinacional).
  • Deve ter módulo 32 (tem 32 estados, conta de 31 até 0 e volta a 31).
    Não há mais restrições explícitas (tipo de flip‑flop), então posso escolher a implementação mais direta.

Passo 2

Escolher o número de flip‑flops.
Para representar 32 estados preciso de n flip‑flops tais que 2^n \ge 32.
2^5 = 32
Logo escolho n=5. Vou usar 5 flip‑flops que armazenam os bits do contador: Q_4,Q_3,Q_2,Q_1,Q_0 (bit mais significativo é Q_4, menos significativo é Q_0).

Passo 3

Escolher o tipo de flip‑flop para implementar.
Vou usar flip‑flops do tipo D porque com D é direto: a lógica combinacional calcula o próximo valor de cada bit e aplica em D_i; no clock seguinte o flip‑flop armazena esse valor. Isso facilita explicar e desenhar na prova sem complicar com tabelas de excitação.

Passo 4

Entender a regra de decremento bit a bit (intuição prática).
Seja Q = (Q_4Q_3Q_2Q_1Q_0)_2. Queremos o próximo estado Q' = Q-1 (aritmética binária com empréstimo/borrow). Regras úteis (observação fácil de ver em exemplos pequenos):
  • O bit menos significativo sempre muda (toglea): Q_0' = \overline{Q_0}.
  • Um bit Q_i (com i>0) muda (togla) se e somente se todos os bits de menor ordem Q_{i-1},\dots,Q_0 forem iguais a 0. Em palavras: há “borrow” até a posição i quando todos os bits menos significativos são 0.
    Exemplo rápido em 3 bits para ver a regra:
  • Q=100_2(=4) Q-1=011_2(=3): aqui Q_0 toggla (de 0 para 1), Q_1 toggla (de 0 para 1) porque Q_0 era 0, Q_2 toggla? não porque nem todos inferiores (Q1,Q0) eram 0 (Q1=0 e Q0=0 actually they were 0 so Q2 toggled from 1 to 0) — o exemplo confirma a regra de borrow propagado quando inferiores são 0.

Passo 5

Traduzir a regra em fórmulas booleanas para entradas D_i dos flip‑flops D.
Defino para cada posição i (onde i=0 é LSB):
  • condição de toggle T_i = \bigwedge_{k=0}^{i-1} \overline{Q_k}. (produto lógico dos complementos dos bits menos significativos; para i=0 o produto é vazio e por convenção T_0=1.)
  • então Q_i' (o próximo valor) é Q_i xor T_i, porque se a condição de toggle for 1 o bit inverte, senão permanece.
Em notação:
D_i = Q_i \oplus \Big(\bigwedge_{k=0}^{i-1} \overline{Q_k}\Big)
Agora escrevo explicitamente para os 5 bits (cada expressão será a entrada D_i do flip‑flop correspondente):
D_0 = \overline{Q_0}
D_1 = Q_1 \oplus \overline{Q_0}
D_2 = Q_2 \oplus (\overline{Q_1}\land\overline{Q_0})
D_3 = Q_3 \oplus (\overline{Q_2}\land\overline{Q_1}\land\overline{Q_0})
D_4 = Q_4 \oplus (\overline{Q_3}\land\overline{Q_2}\land\overline{Q_1}\land\overline{Q_0})
Essas expressões são diretas de implementar com portas NOT, AND e XOR (ou portas equivalentes).

Passo 6

Desenho lógico (descrição de bloco que você deve desenhar na prova).
  • Desenhe 5 flip‑flops D em linha, rotule as saídas Q_4,Q_3,Q_2,Q_1,Q_0. Todos recebem o mesmo clock (síncrono).
  • Para formar D_0 coloque um inversor em Q_0. Saída do inversor vai para D_0.
  • Para D_1 coloque um inversor em Q_0 (pode compartilhar o inversor já usado em D_0), e ligue \overline{Q_0} a uma porta XOR com Q_1. Saída da XOR vai a D_1.
  • Para D_2 use inversores em Q_1 e Q_0, faça uma porta AND de \overline{Q_1} e \overline{Q_0}, e XOR com Q_2 -> D_2.
  • Para D_3 faça AND triple de \overline{Q_2},\overline{Q_1},\overline{Q_0}, XOR com Q_3 -> D_3.
  • Para D_4 faça AND de quatro \overline{Q_3},\overline{Q_2},\overline{Q_1},\overline{Q_0}, XOR com Q_4 -> D_4.
Observações práticas:
  • Pode economizar inversores compartilhando \overline{Q_i} se o desenho físico permitir.
  • XOR pode ser implementado por portas básicas se o exame exigir só NAND/NOR.
  • Não é necessário circuito de reset para garantir módulo 32: um contador de 5 bits decrementando naturalmente percorre os 32 estados cíclicos 31,30,\dots,0,31,\dots. Se quiser forçar um estado inicial use clear/load assíncronos conforme necessidade.

Passo 7

Verificação por exemplo (controle mental rápido para prova):
  • Se Q=(0 0 0 0 0) então \overline{Q_k}=1 para todos k, então todas as condições de toggle são 1 e cada Q_i inverte: próximo Q'=(1 1 1 1 1) que é 31. OK — wraparound correto.
  • Se Q=(1 1 1 1 1) então \overline{Q_0}=0 e somente D_0=\overline{1}=0 e para i>0 as condições de toggle envolvem \overline{Q_0}=0 então T_i=0 e os outros bits permanecem; próximo Q'=(1 1 1 1 0) que é 30. OK.

Resposta

D_0 = \overline{Q_0}
D_1 = Q_1 \oplus \overline{Q_0}
D_2 = Q_2 \oplus (\overline{Q_1}\land\overline{Q_0})
D_3 = Q_3 \oplus (\overline{Q_2}\land\overline{Q_1}\land\overline{Q_0})
D_4 = Q_4 \oplus (\overline{Q_3}\land\overline{Q_2}\land\overline{Q_1}\land\overline{Q_0})

Exercícios relacionados