5- Implemente um contador assíncrono de módulo igual a 16 , ou seja, contagem circular entre 0_{10} e 1610. Considere FF T acionado na borda de descida.

Passo 1

O enunciado pede para implementar um contador assíncrono de módulo 16 (ou seja, que percorre ciclicamente os 16 estados binários de 0 a 15) usando flip‑flops do tipo T que são acionados na borda de descida (borda de subida \to descida do clock). Informações relevantes fornecidas:
  • Módulo do contador: 16 (contagem circular entre 0 e 15 em decimal).
  • Tipo de FF: flip‑flop T.
  • Tipo de disparo: borda de descida (falling edge).
  • É um contador assíncrono (ripple) — os clocks dos FFs subsequentes recebem sinais das saídas dos FFs menos significativos, não um clock comum síncrono.

Passo 2

Entendendo o flip‑flop T (réplica didática e necessária para a prova)
  • Comportamento básico: o flip‑flop T tem entrada T e saída atual Q. A cada borda ativa do clock ele atualiza para um novo estado Q^+ (próximo estado).
  • Equação característica do T:
Q^+ = T \oplus Q
Aqui \oplus é XOR. Explicando: se T=0 então Q^+=Q (mantém estado); se T=1 então Q^+=\overline{Q} (troca o estado).
  • Tabela de transição (útil para projetos):
\begin{array}{c|c|c} Q & T & Q^+ \\\ \hline 0 & 0 & 0\\\\ 1 & 0 & 1\\\\ 0 & 1 & 1\\\\ 1 & 1 & 0 \end{array}
  • Conclusão prática: se eu quiser que um FF faça um “divisor por 2” (toggle a cada pulso), simplesmente coloco T=1 e aplico o clock: a cada borda ativa ele muda de 0 para 1 ou de 1 para 0.

Passo 3

Escolha da arquitetura para contador módulo 16
  • Para contar 16 estados preciso de 4 bits: Q_3 (MSB), Q_2, Q_1, Q_0 (LSB).
  • Como o contador é assíncrono (ripple), a prática clássica com T-FFs é:
    • Todos os T atados a nível lógico 1 (ou seja, sempre habilitados para alternar no evento do clock).
    • O clock externo (entrada do contador) é aplicado ao FF menos significativo FF_0 (que gera Q_0).
    • O clock de FF_1 recebe a saída Q_0.
    • O clock de FF_2 recebe a saída Q_1.
    • O clock de FF_3 recebe a saída Q_2.
  • Importante devido ao enunciado: os FFs são disparados na borda de descida. Isso significa que cada FF alternará quando a respectiva linha de clock fizer a transição 1 \to 0. Ligando os clocks conforme o item acima (cada próximo FF recebe o Q do anterior), teremos a sequência binária natural (incremento por 1 a cada pulso externo) — eu mostro a seguir um exemplo passo a passo para ficar claro.

Passo 4

Demonstração passo a passo de por que essa ligação gera os 16 estados (simulação de algumas transições)
  • Estado inicial assumido: (Q_3,Q_2,Q_1,Q_0) = (0,0,0,0) (pode-se forçar via reset).
  • Ao ocorrer a primeira borda de descida do clock externo (aplicada a FF_0):
    • FF_0 vê uma borda de descida e, com T_0=1, alterna: Q_0:0 \to 1.
    • Como Q_0 subiu de 0 \to 1 (não é uma borda de descida de Q_0), os FF_1,FF_2,FF_3 não são afetados neste instante.
    • Novo estado: (0,0,0,1) — isto é decimal 1.
  • Na segunda borda de descida do clock externo:
    • FF_0 alterna Q_0:1 \to 0. Essa transição é uma borda de descida em Q_0.
    • FF_1 tem seu clock ligado a Q_0 e é sensível à borda de descida, logo FF_1 também alterna (porque T_1=1): Q_1:0 \to 1.
    • Resultado após o “ripple” terminar: (0,0,1,0) — decimal 2.
  • Terceira borda externa:
    • Q_0:0 \to 1 (apenas FF_0 alterna) → (0,0,1,1) decimal 3.
  • Quarta borda externa:
    • Q_0:1 \to 0 provoca borda de descida em Q_0, então FF_1 alterna Q_1:1 \to 0. Essa queda em Q_1 é uma borda de descida que atinge o clock de FF_2, de modo que FF_2 também alterna Q_2:0 \to 1.
    • Estado final após o ripple: (0,1,0,0) decimal 4.
  • Observação geral: cada estágio divide por 2 a frequência do pulso que chega ao seu clock. Assim:
    • Q_0 muda a cada pulso externo (período 2 pulos para completar ciclo).
    • Q_1 muda a cada vez que Q_0 faz 1 \to 0, i.e., a cada 2 pulsos externos.
    • Q_2 muda a cada 4 pulsos externos.
    • Q_3 muda a cada 8 pulsos externos.
  • Como o MSB Q_3 muda a cada 8 pulos e Q_0 a cada pulso, o contador passa por 2^4=16 combinações antes de repetir, ou seja, é módulo 16.

Passo 5

Tabela de estados (rápida verificação)
  • A sequência completa dos 16 estados é:
\begin{array}{r|c} \text{Decimal} & (Q_3,Q_2,Q_1,Q_0) \\\ \hline 0 & (0,0,0,0)\\\\ 1 & (0,0,0,1)\\\\ 2 & (0,0,1,0)\\\\ 3 & (0,0,1,1)\\\\ 4 & (0,1,0,0)\\\\ 5 & (0,1,0,1)\\\\ 6 & (0,1,1,0)\\\\ 7 & (0,1,1,1)\\\\ 8 & (1,0,0,0)\\\\ 9 & (1,0,0,1)\\\\ 10 & (1,0,1,0)\\\\ 11 & (1,0,1,1)\\\\ 12 & (1,1,0,0)\\\\ 13 & (1,1,0,1)\\\\ 14 & (1,1,1,0)\\\\ 15 & (1,1,1,1) \end{array}
  • Depois do estado 15 o próximo pulso traz de volta 0, fechando a contagem módulo 16.

Passo 6

Esquema de ligação final e detalhes práticos para a prova
  • Elementos necessários: 4 flip‑flops T disparados na borda de descida, uma entrada de clock externa CLK e, opcionalmente, um sinal de reset assíncrono para forçar 0000 no power‑on.
  • Ligações:
    • T_0 = T_1 = T_2 = T_3 = 1.
    • CLK_{FF0} = CLK_{ext}.
    • CLK_{FF1} = Q_0.
    • CLK_{FF2} = Q_1.
    • CLK_{FF3} = Q_2.
    • Saídas contadoras: Q_0 (LSB), Q_1, Q_2, Q_3 (MSB).
  • Observações práticas:
    • Como é um contador assíncrono, haverá tempos de propagação (ripple) nas transições — os bits superiores mudam com atraso em relação ao clock externo. Em provas, é suficiente explicar esse comportamento e mostrar a sequência correta.
    • Se o enunciado exigir contagem decrescente (down counter) ao invés de crescente, a mesma técnica funciona trocando‑se a conexão dos clocks para os sinais complementados (usar \overline{Q} em vez de Q) ou alterando polaridade dos FFs; mas aqui a ligação acima com FFs de borda de descida gera a contagem binária natural crescente 0 \to 1 \to 2 \to \dots.

Resposta

  • Use 4 flip‑flops T (LSB = FF_0, MSB = FF_3).
  • Configure T_0=T_1=T_2=T_3=1.
  • Conecte clocks: CLK_{FF0}=CLK_{ext}, CLK_{FF1}=Q_0, CLK_{FF2}=Q_1, CLK_{FF3}=Q_2.
  • Saídas Q_3Q_2Q_1Q_0 fazem a contagem circular 0,1,2,\dots,15 (módulo 16) em sucessivas bordas de descida do CLK_{ext}.

Exercícios relacionados