(2) Projete um contador síncrono para a sequência 0-2-1-3-0 usando FF tipo D , com entradas de 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).
a.(1.0) Apresente a tabela de estados
b.(0.5) Minimização usando Mapa de Karnaugh
c.(0.5) Circuito lógico - para simplificar o cruzamento de fios, pode mostrar os FF separados do circuito lógico e apenas indicar os nomes de onde se ligam.

Passo 1

O enunciado pede que eu projete um contador síncrono que percorre a sequência \,0\to2\to1\to3\to0, usando flip-flops tipo D. As condições e informações dadas são:
  • Os estados são números decimais na sequência indicada; devo escolher a codificação binária adequada para os flip-flops.
  • Os FF são do tipo D, com entradas de clock ( CK), clear ( CLR) e preset ( PR), e saídas Q e Q invertido. O clock é sensível à borda de subida.
  • CLR e PR são ativos em 0 (ou seja, são assíncronos e acionam quando levados a 0).
  • O projeto deve conter:
    a. a tabela de estados (present state \to next state);
    b. minimização usando mapa de Karnaugh;
    c. circuito lógico (posso mostrar os FF separados e indicar onde cada fio se liga).
Não vou resolver nada neste passo; apenas listei o que é pedido e as informações que posso usar.

Passo 2

Escolha da codificação e notação: como a sequência usa os números 0,1,2,3, precisamos de 2 bits. Vou usar:
Q_1 = \text{o bit mais significativo (MSB)},\qquad Q_0 = \text{o bit menos significativo (LSB)}.
Codificação natural (binária) dos estados:
0 \equiv 00,\quad 1 \equiv 01,\quad 2 \equiv 10,\quad 3 \equiv 11.
Portanto a sequência dada em binário é:
00 \to 10 \to 01 \to 11 \to 00.
Explicação didática curta: com flip-flop D síncrono, na borda ativa do clock cada FF recebe no seu pino D o valor que deve assumir em Q após a borda; isto é, para cada FF vale D = Q_{\text{next}}. Assim basta determinar Q_{\text{next}} para cada combinação (Q_1,Q_0) e daí achar as expressões booleanas para D_1 e D_0.

Passo 3

Montagem da tabela de transição (estado presente \to próximo estado) e cálculo direto de Ds usando a regra D = Q_{\text{next}}.
Apresento as linhas listando o estado decimal, o par (Q_1,Q_0), o próximo estado decimal e o par (Q_1^{+},Q_0^{+}) (onde + indica o próximo valor no clock), e por fim os valores de D_1 e D_0 que devem ser aplicados aos FF tipo D:
\begin{array}{c|c|c|c|c} \text{Decimal} & (Q_1,Q_0) & \text{Próx. decimal} & (Q_1^{+},Q_0^{+}) & (D_1,D_0)\\hline 0 & (0,0) & 2 & (1,0) & (1,0)\\\\ 2 & (1,0) & 1 & (0,1) & (0,1)\\\\ 1 & (0,1) & 3 & (1,1) & (1,1)\\\\ 3 & (1,1) & 0 & (0,0) & (0,0) \end{array}ó
Vou escrever essa mesma tabela apenas em termos de bits para facilitar a minimização:
\begin{array}{c c | c c} Q_1 & Q_0 & D_1 & D_0\\hline 0 & 0 & 1 & 0\\\\ 0 & 1 & 1 & 1\\\\ 1 & 0 & 0 & 1\\\\ 1 & 1 & 0 & 0 \end{array}
Comentário didático: cada linha diz "se antes era (Q_1,Q_0), então no próximo pulso devemos ter (Q_1^{+},Q_0^{+})". Como usamos FF tipo D, basta colocar D_1=Q_1^{+} e D_0=Q_0^{+}.

Passo 4

Vamos derivar as funções booleanas de D_1(Q_1,Q_0) e D_0(Q_1,Q_0) a partir da tabela.
Olho primeiro a coluna de D_1:
\begin{array}{c c | c} Q_1 & Q_0 & D_1\\hline 0 & 0 & 1\\\\ 0 & 1 & 1\\\\ 1 & 0 & 0\\\\ 1 & 1 & 0 \end{array}
Repare: para ambos os casos com Q_1=0 (linhas (0,0) e (0,1)), temos D_1=1; para ambos os casos com Q_1=1 temos D_1=0. Isso mostra que D_1 depende só de Q_1 e é simplesmente o complemento de Q_1. Logo:
D_1 = \overline{Q_1}.
Explicação didática: se uma coluna em uma tabela de verdade tem o mesmo valor para todas as linhas onde uma variável vale 0 e o valor oposto quando essa variável vale 1, então essa coluna é simplesmente o inverso dessa variável.
Agora a coluna de D_0:
\begin{array}{c c | c} Q_1 & Q_0 & D_0\\hline 0 & 0 & 0\\\\ 0 & 1 & 1\\\\ 1 & 0 & 1\\\\ 1 & 1 & 0 \end{array}
Isso é a tabela-verdade clássica do XOR: D_0=1 quando os bits são diferentes ( (0,1) e (1,0)), e D_0=0 quando são iguais ( (0,0) e (1,1)). Portanto:
D_0 = Q_1 \oplus Q_0.
Comentário didático: o XOR de duas variáveis é 1 exatamente quando elas diferem; sua expressão em soma de produtos é Q_1\overline{Q_0} + \overline{Q_1}Q_0.

Passo 5

Minimização via Mapa de Karnaugh (explicito o processo, embora aqui seja simples, pois só são 2 variáveis):
Mapa de Karnaugh para D_1 (variáveis Q_1,Q_0):
  • Preencho as células com os valores de D_1: para (0,0)\to1, (0,1)\to1, (1,0)\to0, (1,1)\to0.
  • Agrupo as duas células adjacentes onde D_1=1 (essas duas têm Q_1=0 em comum), obtendo D_1=\overline{Q_1}.
Mapa de Karnaugh para D_0:
  • Preencho as células com os valores de D_0: (0,0)\to0, (0,1)\to1, (1,0)\to1, (1,1)\to0.
  • As células com 1 ficam em posições não adjacentes entre si numa simplificação por pares; o grupo mínimo aqui é cada 1 isolado ou podemos reconhecer diretamente o padrão XOR. A expressão minimizada é:
D_0 = Q_1\overline{Q_0} + \overline{Q_1}Q_0,
que é exatamente D_0 = Q_1 \oplus Q_0.
Observação didática: para duas variáveis o mapa de Karnaugh é rápido — aqui D_1 era uma coluna constante em função de Q_1 e D_0 resultou em XOR.

Passo 6

Implementação prática com FF tipo D — descrição detalhada e conexões (mostro os FF separados do circuito lógico, conforme pedido):
Nomeação:
  • FF para bit mais significativo: FF_1 com saídas Q_1 e \overline{Q_1}.
  • FF para bit menos significativo: FF_0 com saídas Q_0 e \overline{Q_0}.
Equações finais (resumo):
D_1 = \overline{Q_1}, \qquad D_0 = Q_1 \oplus Q_0.
Conexões recomendadas (descrição para montar o circuito):
  • Ligações assíncronas:
    • Para operação normal, mantenha PR=1 (inativo) e CLR=1 (inativo) em ambos os FF.
    • Para forçar estado inicial 0 (ou reset), aplique momentaneamente CLR=0 nos FF (isso coloca Q=0), mantendo PR=1.
    • Atenção: não coloque simultaneamente PR=0 e CLR=0 porque muitos FF têm proibido; siga o fabricante.
  • Ligações de clock:
    • Todos os \,CK dos FF (tanto FF_1 quanto FF_0) recebem o mesmo sinal de clock (contador síncrono). O clock é sensível à borda de subida.
  • Ligações dos pinos D:
    • D do FF_1 (ou seja D_1) conecte ao pino Q invertido de FF_1; em outras palavras, conecte D_1 \leftarrow \overline{Q_1}.
      • Observação prática: como o FF fornece \overline{Q_1} na saída complementar, pode ligar diretamente essa saída \overline{Q_1} ao D_1 (não precisa de inversor extra).
    • D do FF_0 (ou seja D_0) conecte à saída de uma porta XOR cujo inputs são Q_1 e Q_0: D_0 \leftarrow Q_1 \oplus Q_0.
  • Saídas:
    • Os bits do contador são Q_1 e Q_0. As saídas complementares também estão disponíveis se precisar ( \overline{Q_1},\overline{Q_0}).
Pequeno passo-a-passo de operação (verificação):
  • Estado inicial 00. Na próxima borda de subida:
    • D_1= \overline{Q_1}=1 e D_0=Q_1\oplus Q_0=0\Rightarrow próximo estado 10 (decimal 2) — OK.
  • De 10: D_1=\overline{1}=0, D_0=1\oplus0=1 \Rightarrow próximo 01 (decimal 1) — OK.
  • E assim por diante; a sequência se repete.

Passo 7

Comentários finais motivacionais e de verificação: o projeto ficou bem simples porque com dois bits a lógica se reduz a um inversor (que já vem com a saída complementar do FF) e uma porta XOR. Isso é ótimo para prova: memorizando a técnica (fazer a tabela, escrever D=Q^{+}, depois simplificar com K-map) você resolve rapidamente contadores customizados. Força aí — está no caminho certo!

Resposta

a. Tabela de estados:
\begin{array}{c|c|c|c} \text{Decimal} & (Q_1,Q_0) & (Q_1^{+},Q_0^{+}) & (D_1,D_0)\\hline 0 & (0,0) & (1,0) & (1,0)\\\\ 2 & (1,0) & (0,1) & (0,1)\\\\ 1 & (0,1) & (1,1) & (1,1)\\\\ 3 & (1,1) & (0,0) & (0,0) \end{array}
b. Expressões minimizadas (obtidas por K-map):
D_1 = \overline{Q_1}
D_0 = Q_1 \oplus Q_0 \quad\text{(equivalente a }\;Q_1\overline{Q_0}+\overline{Q_1}Q_0\text{)}
c. Circuito lógico (descrição das ligações):
  • Dois FF tipo D: FF_1 (MSB) e FF_0 (LSB). Ambos com CK ao mesmo clock (borda de subida).
  • Conexões dos D:
    • D_1 do FF_1 ligado diretamente à saída complementar \overline{Q_1} de FF_1 (ou, equivalentemente, a um inversor em Q_1).
    • D_0 do FF_0 ligado à saída de uma porta XOR com entradas Q_1 e Q_0: D_0 \leftarrow Q_1 \oplus Q_0.
  • PR e CLR (ativos em 0): mantê-los em 1 para operação normal; para reset inicial ao estado 00 momentaneamente colocar CLR=0 (com PR=1).

Exercícios relacionados