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