Obter um contador módulo12 síncrono crescente, utilizando flip-flops D.

Passo 1

O que o enunciado pede e o que temos de informação:
  • Pede: projetar um contador síncrono crescente módulo 12 usando flip-flops D.
  • O contador deve percorrer as sequências de 0 a 11 (ou seja, estados 0,1,\dots,11) e depois voltar a 0.
  • Informação usada: vou usar codificação binária natural com 4 bits porque 12 \le 16. Os bits (flip-flops) serão, do mais significativo ao menos significativo, Q_3, Q_2, Q_1, Q_0.
  • Regras que usarei sem perguntar nada: cada entrada D_i do flip-flop i deve ser igual ao bit do próximo estado (ou seja, D_i = bit i do estado seguinte). Para estados não usados ( 12 a 15) tratarei como “don’t care” para simplificar a lógica.
Perguntas explícitas (decifrando o enunciado):
  • Definir a tabela de transição (estado atual \to próximo estado) para 0 a 11.
  • Encontrar as expressões lógicas minimalizadas para D_0, D_1, D_2, D_3.
  • Indicar como conectar os flip‑flops (todos síncronos ao mesmo clock) e os blocos lógicos necessários.

Passo 2

Código dos estados e tabela de transição (peguei os valores da sequência natural n\mapsto (n+1)\bmod 12):
\begin{array}{c c c c c} \text{decimal} & Q_3Q_2Q_1Q_0 & \longrightarrow & \text{próx.} & N_3N_2N_1N_0\\hline 0 & 0000 & \longrightarrow & 0001 & \\\\ 1 & 0001 & \longrightarrow & 0010 & \\\\ 2 & 0010 & \longrightarrow & 0011 & \\\\ 3 & 0011 & \longrightarrow & 0100 & \\\\ 4 & 0100 & \longrightarrow & 0101 & \\\\ 5 & 0101 & \longrightarrow & 0110 & \\\\ 6 & 0110 & \longrightarrow & 0111 & \\\\ 7 & 0111 & \longrightarrow & 1000 & \\\\ 8 & 1000 & \longrightarrow & 1001 & \\\\ 9 & 1001 & \longrightarrow & 1010 & \\\\ 10 & 1010 & \longrightarrow & 1011 & \\\\ 11 & 1011 & \longrightarrow & 0000 & \end{array}ó
Observação: estados 12 ( 1100) até 15 ( 1111) são não usados — vou tratá‑los como “don’t care” ( X) para facilitar minimizações.

Passo 3

Regra do flip‑flop D e observação prática:
  • Lembre: para um flip‑flop D síncrono, a entrada no instante do clock determina o próximo valor do Q. Logo:
D_i = N_i,
onde N_i é o valor do bit i no próximo estado. Assim basta determinar N_0,N_1,N_2,N_3 em função de Q_3,Q_2,Q_1,Q_0 (estado atual).

Passo 4

Derivação direta de D_0 e D_1 (casos simples ensinando o conceito):
  • D_0 (bit menos significativo): ao contar +1, o LSB simplesmente troca (flip) a cada pulso. Então o próximo LSB é o complemento do atual. Em notação:
D_0 = \overline{Q_0}.
Explicando: se Q_0=0 vira 1, se Q_0=1 vira 0. Fácil de implementar com uma porta NOT.
  • D_1 (segundo bit): ao incrementar, Q_1 muda quando há carry de Q_0, ou seja, quando Q_0=1. Isso é exatamente uma operação XOR entre Q_1 e Q_0. Logo:
D_1 = Q_1 \oplus Q_0.
Explicando: XOR retorna 1 se os dois bits diferem — é o comportamento do bit seguinte ao LSB numa soma de 1.

Passo 5

Derivação de D_2 com raciocínio passo a passo (usando don’t cares para simplificar):
  • Olhando a tabela, N_2 vale 1 apenas quando o estado atual é 3,4,5,6 (ou seja, 0011,0100,0101,0110). Para os demais 0\le n\le 11 é 0. Estados 12 15 tratamos como X.
  • Agrupando esses mintermos e aproveitando que Q_3=0 nesses casos, obtemos uma expressão compacta. Um modo didático de ver: N_2 é igual a Q_2 xor (produto dos dois bits inferiores) quando Q_3=0. Em fórmula:
D_2 = \overline{Q_3}\,\bigl(Q_2 \oplus (Q_1 Q_0)\bigr).
Explicando bem: Q_1 Q_0 é o “sinal de carry” das duas posições inferiores; Q_2\oplus(Q_1Q_0) corresponde ao comportamento de incremento do bit 2 numa adição normal, mas multiplicamos por \overline{Q_3} porque quando Q_3=1 (estados 8…11) o padrão muda devido ao wrap em 11\to 0. O fator \overline{Q_3} define que só aplicamos esse comportamento quando Q_3=0, resultando exatamente nos mintermos desejados.
  • Se quiser ver expandido para portas básicas:
D_2 = \overline{Q_3}\,\bigl(Q_2\overline{(Q_1Q_0)} + \overline{Q_2}(Q_1Q_0)\bigr)
ou usando De Morgan para \overline{(Q_1Q_0)}=\overline{Q_1}+\overline{Q_0}.

Passo 6

Derivação de D_3 com explicação e tratamento do caso de retorno (wrap):
  • Observando a tabela, N_3=1 para estados 7,8,9,10 (ou seja 0111,1000,1001,1010). Para 11 ( 1011) N_3=0 — esse é o caso que força o retorno a zero. Estados 12 15 são X.
  • Uma expressão direta que cobre os mintermos é:
D_3 = Q_3\overline{Q_2}\,\overline{(Q_1Q_0)} \;+\; \overline{Q_3}\,Q_2\,Q_1\,Q_0.
Explicando termo a termo:
  • O termo Q_3\overline{Q_2}\,\overline{(Q_1Q_0)} cobre os estados com Q_3=1,Q_2=0 exceto o caso Q_1Q_0=11 (que é o estado 11 e deve levar a N_3=0). Portanto usamos \overline{(Q_1Q_0)} para excluir \,Q_1Q_0=11.
  • O termo \overline{Q_3}Q_2Q_1Q_0 cobre o caso do estado 7 ( 0111), que também tem N_3=1.
  • Podemos reescrever \overline{(Q_1Q_0)}=\overline{Q_1}+\overline{Q_0} se preferir portas AND/OR/NOT:
D_3 = Q_3\overline{Q_2}(\overline{Q_1}+\overline{Q_0}) \;+\; \overline{Q_3}Q_2Q_1Q_0.

Passo 7

Resumo da implementação física (como montar o circuito):
  • Use quatro flip‑flops D com entradas D_3,D_2,D_1,D_0 e todos ligados ao mesmo clock (síncrono).
  • Gere sinais auxiliares:
    • A = Q_1 Q_0 (AND dos dois LSBs).
    • X_{01} = Q_1 \oplus Q_0 (XOR para D_1).
    • B = Q_2 \oplus A (XOR entre Q_2 e A) — útil para D_2.
    • \overline{Q_3}, \overline{Q_2}, \overline{Q_1}, \overline{Q_0} com inversores conforme necessário.
  • Ligue:
    • D_0 = \overline{Q_0} (inversor).
    • D_1 = X_{01} (porta XOR).
    • D_2 = \overline{Q_3}\cdot B (AND entre \overline{Q_3} e B).
    • D_3 = Q_3\overline{Q_2}(\overline{Q_1}+\overline{Q_0}) + \overline{Q_3}Q_2Q_1Q_0 (combinação de ANDs e ORs conforme expressão).
  • Observação prática: se preferir reduzir portas, use as portas básicas disponíveis (XOR, AND, OR, NOT) e aproveite don’t cares para simplificar em implementação real.

Resposta

D_0=\overline{Q_0}\
D_1=Q_1\oplus Q_0\
D_2=\overline{Q_3}\,\bigl(Q_2\oplus(Q_1Q_0)\bigr)\
D_3=Q_3\overline{Q_2}(\overline{Q_1}+\overline{Q_0})+\overline{Q_3}Q_2Q_1Q_0

Exercícios relacionados