(1.5) Projete um contador assíncrono 0-1-2-3-4-0 usando FF T com entradas CK, CLR, PR e saídas Q e Q\ (inverso de Q), e clock sensível a borda de subida. (CLR e PR são ativos em 0).

Passo 1

O que o enunciado pede e o que foi dado:
  • Pede projetar um contador assíncrono que conte na sequência 0 → 1 → 2 → 3 → 4 → 0 (ou seja, módulo 5), usando flip-flops do tipo T.
  • Cada flip-flop T tem entradas \text{CK}, \overline{\text{CLR}} (clear assíncrono ativo em 0), \overline{\text{PR}} (preset assíncrono ativo em 0), e saídas Q e \overline{Q}.
  • O clock principal é sensível à borda de subida (rising edge).
  • Não há restrição extra sobre portas lógicas; podemos usar lógica combinacional para gerar sinais de clear/preset.
  • O contador deve repetir 0,1,2,3,4,0,… continuamente.
Informações relevantes extraídas do enunciado (listas de dados):
  • Sequência desejada em binário (usando 3 bits Q_2 Q_1 Q_0 para representar 0…4):
    0 = 000, 1 = 001, 2 = 010, 3 = 011, 4 = 100, volta para 0 = 000.
  • \overline{\text{CLR}} e \overline{\text{PR}} são ativos em 0 (ou seja, levam o FF a limpar/presetar quando em nível baixo).
  • Os FF têm saída complementar disponível; isso será útil para detecção de estados sem inversores extras.

Passo 2

Escolha do método e motivos (por que usar um contador assíncrono tipo ripple com T=1):
  • O enunciado pede explicitamente um contador “assíncrono”. A forma clássica é o contador ripple (assíncrono) em que cada FF menos significativo fornece o clock do FF seguinte. Isso é direto de implementar e usa bem a característica de borda dos FFs.
  • Para T-FFs, a característica é simples: se T=1 o FF inverte Q na borda ativa; se T=0 mantém Q. Então a maneira mais simples de fazer um contador binário ripple é colocar T=1 em todos os FFs e cascatar os clocks.
  • Com 3 flip-flops (mínimo necessário para representar 0…4) obtemos um contador binário 3-bit que vai de 000 a 111. Para torná-lo módulo 5, usamos a entrada assíncrona \overline{\text{CLR}} para detectar o estado proibido (5 = 101) e forçar 000 imediatamente.
  • Risco/hazards: usar clear assíncrono que dispara quando o estado 101 aparece é típico e aceitável; o estado 101 será cancelado assincronamente para 000, resultando na sequência desejada. Como o enunciado pede assíncrono, essa solução é pedagógica e simples.

Passo 3

Relembrando como funciona o flip-flop T (a “aula” prática):
  • Característica do T-FF: na borda ativa (aqui borda de subida), a próxima saída Q^+ é dada por
Q^+ = T \oplus Q.
Isso significa:
  • Se T=0, então Q^+ = Q (mantém).
  • Se T=1, então Q^+ = \overline{Q} (toggle).
  • Para um contador ripple binário ascendente com T-FFs, define-se T_0=T_1=T_2=1. Liga-se o clock principal ao \text{CK} do FF menos significativo (LSB), e o \text{CK} do próximo FF é ligado ao Q do FF anterior (para FFs sensíveis a borda de subida isso causa toggles do nível apropriado).
  • Exemplificando o ripple: \text{CK}_0 = \text{CLK}, \text{CK}_1 = Q_0, \text{CK}_2 = Q_1. A cada borda de subida do clock principal, Q_0 pode mudar; quando Q_0 faz 0→1, isso produz uma borda de subida em \text{CK}_1, fazendo Q_1 togglar, e assim por diante. Resultado: contagem binária natural.

Passo 4

Construção do contador binário ripple 3-bit (antes de modularizar):
  • Usamos três T-FFs: FF0 (LSB) com saída Q_0, FF1 com Q_1, FF2 (MSB) com Q_2.
  • Ligações básicas:
    • T_0 = 1, T_1 = 1, T_2 = 1.
    • \text{CK}_0 = \text{CLK (entrada)}.
    • \text{CK}_1 = Q_0.
    • \text{CK}_2 = Q_1.
  • Se não fizermos nada mais, o circuito contaria: 000 \to 001 \to 010 \to 011 \to 100 \to 101 \to 110 \to 111 \to 000 \to \dots (sequência binária natural).
  • Nosso objetivo é interromper essa sequência ao alcançar 101 (decimal 5) e forçar 000 imediatamente, produzindo 0,1,2,3,4,0,…

Passo 5

Detectando o estado 5 ( 101) e usando \overline{\text{CLR}} assíncrono para voltar a 0:
  • Condição para estado decimal 5 é:
Q_2 = 1,\quad Q_1 = 0,\quad Q_0 = 1.
  • Queremos que, quando isso acontecer, a entrada \overline{\text{CLR}} dos três FFs vá a nível logicamente baixo (ativo) para forçar todas as saídas a 0 (estado 000) de forma assíncrona.
  • Uma expressão booleana que é verdadeira exatamente no estado 101 é D = Q_2 \cdot \overline{Q_1} \cdot Q_0.
  • Como \overline{\text{CLR}} é ativa em 0, devemos acionar \overline{\text{CLR}} = 0 quando D=1. Ou seja, \overline{\text{CLR}} deve ser a negação de D:
\overline{\text{CLR}} = \overline{Q_2 \cdot \overline{Q_1} \cdot Q_0}.
  • Isso pode ser implementado com uma porta NAND de três entradas se usarmos a saída complementar \overline{Q_1} já disponível no flip-flop: conecte as três entradas da NAND em Q_2, \overline{Q_1} e Q_0. A saída da NAND ficará em 0 exatamente quando Q_2=1,\\ \overline{Q_1}=1,\\ Q_0=1, i.e. Q_2=1,Q_1=0,Q_0=1.
  • Portanto, ligar a saída dessa NAND em paralelo às entradas \overline{\text{CLR}} dos três FFs implementa o reset assíncrono para retornar a 000 assim que o contador tentar entrar em 101.
Observação didática: usamos \overline{Q_1} porque os FFs já dão essa saída; assim evitamos um inversor extra. Se por algum motivo não tivéssemos \overline{Q_1}, poderíamos inverter Q_1 com porta extra e então usar uma NAND.

Passo 6

Comportamento temporário / sequência final (o que acontece ao longo do tempo):
  • Começando em 000:
    • Pulsos de clock: 000 \to 001 \to 010 \to 011 \to 100.
    • No próximo passo o contador iria para 101 (se não houvesse correção), mas assim que os FFs atingem 101 a saída da nossa NAND se torna 0 e aciona \overline{\text{CLR}} = 0 (assíncrono), forçando imediatamente todas as saídas para 000.
    • Resultado visto externamente: 000 \to 001 \to 010 \to 011 \to 100 \to 000 \to 001 \to \dots — sequência módulo 5 correta.
  • Nota sobre exibição do estado 101: dependendo das transições e atrasos, o estado 101 pode aparecer por um tempo muito curto ou nem aparecer visivelmente (porque o clear é assíncrono). Para a finalidade do contador módulo 5 isso é esperado e aceitável.

Passo 7

Resumo das conexões finais (modo de ligação do circuito) — instruções para montar o circuito:
  • Flip-flops: FF2 (MSB), FF1, FF0 (LSB), com saídas Q_2,Q_1,Q_0 e complementares \overline{Q_2},\overline{Q_1},\overline{Q_0}.
  • Entradas T:
T_0 = 1,\quad T_1 = 1,\quad T_2 = 1.
  • Clocks:
\text{CK}_0 = \text{CLK (entrada principal)},\quad \text{CK}_1 = Q_0,\quad \text{CK}_2 = Q_1.
  • Sinal de clear assíncrono (cada \overline{\text{CLR}} dos três FFs ligado em paralelo à saída de uma NAND 3-entradas):
\overline{\text{CLR}} = \overline{Q_2 \cdot \overline{Q_1} \cdot Q_0}.
Implementação prática: use uma porta NAND de 3 entradas com entradas Q_2,\\ \overline{Q_1},\\ Q_0. A saída da NAND vai para as três entradas \overline{\text{CLR}} dos FFs.
  • Preset assíncrono:
\overline{\text{PR}} = 1 \quad (\text{ligado a nível alto, inativo}).í
  • Com essas ligações o contador conta 000 \to 001 \to 010 \to 011 \to 100 \to 000 \to \dots, implementando 0–4–0 ciclo assíncrono.

Resposta

T_0=1,\\ T_1=1,\\ T_2=1
\text{CK}_0=\text{CLK (entrada)},\\ \text{CK}_1=Q_0,\\ \text{CK}_2=Q_1
\overline{\text{CLR}}=\overline{Q_2\cdot\overline{Q_1}\cdot Q_0} (implemente como NAND de entradas Q_2,\\ \overline{Q_1},\\ Q_0 e conecte a todos os \overline{\text{CLR}})
\overline{\text{PR}}=1

Exercícios relacionados