Projete um contador síncrono usando flip-flop JK para contagem da seguinte sequência binária:
000, 010, 100, 110, 111, 000, 010, …
Neste projeto as saídas Q dos flips-flops, são definidas como \mathrm{QA}, \mathrm{QB} e QC , representam a contagem binária a ser realizada, sendo QA a saída menos significativa e QC a saída mais significativa.
Desenhe a máquina de estado, monte a tabela verdade e projete o circuito proposto. Considere que o contador seja inicializado em qualquer um dos estados presentes na sequência, de forma que os estados não presentes nunca sejam alcançados.
Passo 1
O enunciado dá a sequência cíclica de estados de 3 bits (com Q_A menos significativo e Q_C mais significativo):
desenhar a máquina de estados (mostrar os estados e transições);
montar a tabela verdade (estados presentes \to próximos estados);
projetar o circuito usando flip-flop JK (ou seja, obter as funções de entrada J e K para cada flip-flop A,B,C).
Informações/restrições adicionais que devemos usar:
o contador é síncrono (todos os clocks conectados em paralelo);
quaisquer estados que não aparecem na sequência são considerados “não alcançados” (podem ser tratados como don’t cares ao simplificar as expressões);
as saídas atuais são Q_A, Q_B, Q_C e definem o estado presente; devemos determinar Q_A^+, Q_B^+, Q_C^+ (próximos valores) e, a partir deles, as entradas J e K.
A resolução começa no Passo 2.
Passo 2
Desenho (descrição) da máquina de estados.
Os cinco estados usados são, em ordem de contagem:(Q_C Q_B Q_A)=000 \to 010 \to 100 \to 110 \to 111 \to 000.
Cada estado é um nó; as setas são:000 \xrightarrow{} 010,\quad 010 \xrightarrow{} 100,\quad 100 \xrightarrow{} 110,\quad 110 \xrightarrow{} 111,\quad 111 \xrightarrow{} 000.
(Visualize um ciclo com 5 nós nessas ordens; isso é a máquina de estados.)
Passo 3
Tabela de transição (tabela verdade do contador): escrevo cada estado presente e seu próximo estado.
Isto significa: se queremos 0→1 precisamos J=1; se queremos 1→0 precisamos K=1; quando o valor é “não altera” a entrada correspondente pode ser 0 ou X dependendo do caso. Vamos aplicar isso linha a linha da tabela do contador para cada flip-flop.
Passo 5
Aplicando a tabela de excitação estado a estado e flip a flip. Para cada linha da tabela de transição extraio as exigências de J e K.
Linha 1: estado 000\to010
Q_A: 0\to0\Rightarrow J_A=0,\\ K_A=\text{X}.
Q_B: 0\to1\Rightarrow J_B=1,\\ K_B=\text{X}.
Q_C: 0\to0\Rightarrow J_C=0,\\ K_C=\text{X}.
Linha 2: estado 010\to100
Q_A: 0\to0\Rightarrow J_A=0,\\ K_A=\text{X}.
Q_B: 1\to0\Rightarrow J_B=\text{X},\\ K_B=1.
Q_C: 0\to1\Rightarrow J_C=1,\\ K_C=\text{X}.
Linha 3: estado 100\to110
Q_A: 0\to0\Rightarrow J_A=0,\\ K_A=\text{X}.
Q_B: 0\to1\Rightarrow J_B=1,\\ K_B=\text{X}.
Q_C: 1\to1\Rightarrow J_C=\text{X},\\ K_C=0.
Linha 4: estado 110\to111
Q_A: 0\to1\Rightarrow J_A=1,\\ K_A=\text{X}.
Q_B: 1\to1\Rightarrow J_B=\text{X},\\ K_B=0.
Q_C: 1\to1\Rightarrow J_C=\text{X},\\ K_C=0.
Linha 5: estado 111\to000
Q_A: 1\to0\Rightarrow J_A=\text{X},\\ K_A=1.
Q_B: 1\to0\Rightarrow J_B=\text{X},\\ K_B=1.
Q_C: 1\to0\Rightarrow J_C=\text{X},\\ K_C=1.
Agora, a partir dessas exigências, extraio onde J=1 (mínimos) e onde K=1 (mínimos) — os X (don’t care) podem ser usados para simplificar.
Passo 6
Determinar os minterms (linhas em que J ou K devem valer 1) para cada flip-flop.
Flip-flop A (Q_A):
J_A=1 aparece na linha do estado 110 (porque ali 0→1). Então minterm: Q_C=1,Q_B=1,Q_A=0 → termo Q_C Q_B \overline{Q_A}.
K_A=1 aparece na linha do estado 111 (1→0) → termo Q_C Q_B Q_A.
As outras linhas exigem J_A=0 ou são don’t care para K_A.
Simplificação para A:
Observe que tanto o minterm de J_A quanto o minterm de K_A têm fator comum Q_C Q_B. Podemos escolher funções que aproveitem os don’t cares. Uma implementação simples e mínima é:J_A = Q_C Q_B,\qquad K_A = Q_C Q_B.
Isso funciona porque:
para 110 (Q_CQ_B=1) obtemos J=K=1 → JK=11 (toggle) transforma Q_A=0 em 1 (desejado);
para 111 (Q_CQ_B=1) JK=11 toggle transforma 1 em 0 (desejado);
nos demais estados Q_CQ_B=0 então JK=00 (no change) e Q_A permanece 0 (desejado).
Flip-flop B (Q_B):
J_B=1 nas linhas 000 e 100 (estes são os casos 0→1), isto é nos minterms 000 e 100.
100 = Q_C\,\overline{Q_B}\,\overline{Q_A}.
Ambas têm \overline{Q_B}\,\overline{Q_A} em comum ⇒
J_B = \overline{Q_A}\,\overline{Q_B}.
K_B=1 nas linhas 010 e 111 (estes são os casos 1→0), ou seja minterms 010 e 111:
010 = \overline{Q_C}\,Q_B\,\overline{Q_A}.
111 = Q_C\,Q_B\,Q_A.
Factorizando Q_B:
K_B = Q_B\big(\overline{Q_C}\,\overline{Q_A} + Q_C\,Q_A\big).Nota: \overline{Q_C}\,\overline{Q_A} + Q_C\,Q_A é (Q_A \leftrightarrow Q_C) (XNOR entre Q_A e Q_C). Mantemos a forma somatória para implementação com portas AND/OR:K_B = Q_B\big(\overline{Q_A}\,\overline{Q_C} + Q_A Q_C\big).
Flip-flop C (Q_C):
J_C=1 aparece na linha 010 (0→1), isto é minterm 010 = \overline{Q_C}\,Q_B\,\overline{Q_A}. Observando don’t cares, podemos simplificar para:J_C = Q_B\,\overline{Q_A}.(Isto também cobre o estado 110 onde J era don’t care; isso não prejudica o comportamento porque em 110 já temos K_C=0 e o flip está em 1.)
K_C=1 aparece apenas na linha 111 → minterm Q_C Q_B Q_A. Podemos adotar:K_C = Q_C Q_B Q_A.
Passo 7
Resumo das simplificações e verificação rápida (didática e intuitiva):
Para A notamos que Q_A só muda quando Q_C Q_B = 1. Portanto usar J_A=K_A=Q_C Q_B é elegante: quando Q_CQ_B=0 não muda, quando =1 toggla (o que produz 0→1 em 110 e 1→0 em 111).
Para B, J_B é 1 quando Q_A=0 e Q_B=0 (isto é, \overline{Q_A}\,\overline{Q_B}). K_B é 1 nos dois casos onde Q_B deve passar a 0 (010 e 111), o que leva à expressão com Q_B fatorado.
Para C, J_C só precisa ser 1 em 010; com don’t cares podemos estender a Q_B\overline{Q_A}. K_C é 1 apenas em 111, então K_C=Q_CQ_BQ_A.
Passo 8
Projeto do circuito (descrição de ligações, pronto para implementar):
Todos os clocks dos três FF JK são comuns (síncrono).
Implementação prática: usar inversores para \overline{Q_A},\overline{Q_B},\overline{Q_C}; portas AND para produtos; portas OR para somas (por exemplo \overline{Q_A}\,\overline{Q_C} + Q_A Q_C é duas ANDs cujas saídas entram numa OR, essa saída AND com Q_B dá K_B).
Observação: como estados não usados são don’t cares, esta implementação garante que, partindo de qualquer um dos cinco estados, o circuito seguirá exatamente a sequência desejada. Estados não previstos (se por algum motivo atingidos) não fazem parte da sequência — o enunciado permitiu considerá-los não alcançados.
Passo 9
Verificação de consistência (rápida):
Testando cada linha da tabela com as fórmulas obtidas confirma-se que as transições coincidem com a sequência desejada; as escolhas com don’t cares não introduzem transições indesejadas nos estados utilizados.