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):
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:
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.
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.
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:
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.