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):
000 \to 010 \to 100 \to 110 \to 111 \to 000 \to \dots
As tarefas pedidas são:
  • 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.
\begin{array}{c c c \;\to\; c c c} Q_C & Q_B & Q_A & Q_C^+ & Q_B^+ & Q_A^+\\hline 0 & 0 & 0 & 0 & 1 & 0\\\\ 0 & 1 & 0 & 1 & 0 & 0\\\\ 1 & 0 & 0 & 1 & 1 & 0\\\\ 1 & 1 & 0 & 1 & 1 & 1\\\\ 1 & 1 & 1 & 0 & 0 & 0 \end{array}
(Outros combinações de Q_CQ_BQ_A são estados não usados e serão tratados como don’t cares na simplificação.)

Passo 4

Lembrete didático: tabela de excitação do flip-flop JK
  • para passar de Q para Q^+ as entradas J,K mínimas necessárias são:
\begin{array}{c c c} Q & Q^+ & (J,K) \text{ mínimo}\\hline 0 & 0 & (0,\text{X})\\\\ 0 & 1 & (1,\text{X})\\\\ 1 & 0 & (\text{X},1)\\\\ 1 & 1 & (\text{X},0) \end{array}í
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.
    • 000 = \overline{Q_C}\,\overline{Q_B}\,\overline{Q_A}.
    • 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).
  • Entradas: \begin{aligned} J_A &= Q_C\,Q_B,\\\ K_A &= Q_C\,Q_B; \end{aligned} \qquad \begin{aligned} J_B &= \overline{Q_A}\,\overline{Q_B},\\\ K_B &= Q_B\big(\overline{Q_A}\,\overline{Q_C} + Q_A Q_C\big); \end{aligned} \qquad \begin{aligned} J_C &= Q_B\,\overline{Q_A},\\\ K_C &= Q_C\,Q_B\,Q_A. \end{aligned}
  • 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 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.

Resposta

Máquina de estados: 000 \to 010 \to 100 \to 110 \to 111 \to 000.
Tabela de transição:
\begin{array}{c c c \;\to\; c c c} Q_C & Q_B & Q_A & Q_C^+ & Q_B^+ & Q_A^+\\hline 0 & 0 & 0 & 0 & 1 & 0\\\\ 0 & 1 & 0 & 1 & 0 & 0\\\\ 1 & 0 & 0 & 1 & 1 & 0\\\\ 1 & 1 & 0 & 1 & 1 & 1\\\\ 1 & 1 & 1 & 0 & 0 & 0 \end{array}
Funções das entradas JK (implementação proposta):
\begin{aligned} J_A &= Q_C\,Q_B,\\\ K_A &= Q_C\,Q_B; \end{aligned} \qquad \begin{aligned} J_B &= \overline{Q_A}\,\overline{Q_B},\\\ K_B &= Q_B\big(\overline{Q_A}\,\overline{Q_C} + Q_A Q_C\big); \end{aligned} \qquad \begin{aligned} J_C &= Q_B\,\overline{Q_A},\\\ K_C &= Q_C\,Q_B\,Q_A. \end{aligned}

Exercícios relacionados