4- Projetar com Flip-Flop tipo D um circuito digital para um contador cíclico que faça a seqüência 5 \rightarrow 1 \rightarrow 6 \rightarrow 3 \rightarrow 0. Considere que o estado 2 vai incondicionalmente para o estado 3 . Desenvolva a tabela de transições de estados, forneça as expressões booleanas para os flip-flops e desenhe o circuito, considerando todas as situações possíveis.

Passo 1

O enunciado pede que a gente projete um contador cíclico usando flip-flops do tipo D que percorra a sequência
5 \rightarrow 1 \rightarrow 6 \rightarrow 3 \rightarrow 0
e que também seja obedecida a condição: o estado 2 vai incondicionalmente para o estado 3. Além disso o enunciado exige que sejam consideradas “todas as situações possíveis” — ou seja, devemos especificar o comportamento para todos os estados de 3 bits (de 0 a 7), não só para os estados que aparecem na sequência.
Informações relevantes dadas:
  • Sequência desejada (cíclica): 5 \to 1 \to 6 \to 3 \to 0 \to 5 (fechando o ciclo em 5).
  • Transição obrigatória: 2 \to 3.
  • Devemos usar flip-flops tipo D (lembre: o valor na entrada D será o valor do próximo estado no clock seguinte).
  • Devemos desenvolver a tabela de transição completa, obter as expressões booleanas para as entradas D dos flip-flops e desenhar/indicar o circuito lógico que implementa essas expressões.
  • Não foi dado um mapeamento explícito dos bits; vamos escolher um mapeamento binário natural de 3 bits para os números 0 a 7.
Não vou resolver ainda — só organizei o que foi pedido e as informações que vamos usar.

Passo 2

Escolha de codificação e nome dos flip-flops (padrão e simples, fácil de usar na prova):
  • Usamos três flip-flops Q_2, Q_1, Q_0 que armazenam o estado atual em binário com Q_2 como bit mais significativo (MSB) e Q_0 como LSB.
  • A codificação binária decimal \leftrightarrow bits fica:
    • 0 \leftrightarrow 000
    • 1 \leftrightarrow 001
    • 2 \leftrightarrow 010
    • 3 \leftrightarrow 011
    • 4 \leftrightarrow 100
    • 5 \leftrightarrow 101
    • 6 \leftrightarrow 110
    • 7 \leftrightarrow 111
Regra prática importante (teoria curta sobre flip-flop D):
  • Um flip-flop D atualiza seu Q na borda do clock com o valor presente em D. Logo, para obter a transição desejada, devemos colocar em cada entrada D_i a função booleana que gera o valor do bit i do próximo estado em função dos bits atuais Q_2,Q_1,Q_0. Em fórmulas: D_2 = Q_2^{+},\qquad D_1 = Q_1^{+},\qquad D_0 = Q_0^{+},onde Q_i^{+} é o valor do bit i no próximo estado.

Passo 3

Construção da tabela completa de transições (decidimos uma política para os estados não especificados):
  • Já temos explicitamente as transições da sequência:
    • 5(101)\rightarrow1(001)
    • 1(001)\rightarrow6(110)
    • 6(110)\rightarrow3(011)
    • 3(011)\rightarrow0(000)
    • 0(000)\rightarrow5(101) (fechando o ciclo)
  • E a condição adicional: 2(010)\rightarrow3(011).
  • Restam os estados 4(100) e 7(111) — o enunciado pede que “consideremos todas as situações possíveis”. Para esses estados residuais devemos definir uma saída de forma que o circuito “recupere” e entre no ciclo desejado. Uma escolha simples e comum é direcioná-los para o início do ciclo, por exemplo para 5(101). Isso evita estados “mortos” e garante que o circuito sempre entre na sequência definida.
    • Assim adotamos:
      • 4(100)\rightarrow5(101)
      • 7(111)\rightarrow5(101)
Agora a tabela de transição completa (lista: estado presente \to próximo estado):
  • 0\\ (000) \rightarrow 5\\ (101)
  • 1\\ (001) \rightarrow 6\\ (110)
  • 2\\ (010) \rightarrow 3\\ (011) (dado)
  • 3\\ (011) \rightarrow 0\\ (000)
  • 4\\ (100) \rightarrow 5\\ (101) (decisão para recuperação)
  • 5\\ (101) \rightarrow 1\\ (001)
  • 6\\ (110) \rightarrow 3\\ (011)
  • 7\\ (111) \rightarrow 5\\ (101) (decisão para recuperação)
Observação didática: mapear estados não especificados para um estado do ciclo é uma prática comum para tratamento de estados inválidos — outra opção seria projetar “don’t care” e otimizar as expressões, mas aqui escolhemos uma política determinística (vai para 5).

Passo 4

Transformar a tabela de transições em funções para D_2,D_1,D_0 (passo-a-passo):
  • Para cada linha da tabela, o bit i do próximo estado é o valor que a entrada D_i deve assumir quando o estado presente for aquele da linha. Assim listamos os valores de Q_2^{+},Q_1^{+},Q_0^{+} para cada presente (Q_2Q_1Q_0).
Vou escrever a tabela em forma compacta (presente Q_2Q_1Q_0 → próximo Q_2^{+}Q_1^{+}Q_0^{+}):
  • 000 \to 101
  • 001 \to 110
  • 010 \to 011
  • 011 \to 000
  • 100 \to 101
  • 101 \to 001
  • 110 \to 011
  • 111 \to 101
Agora separamos as colunas para cada D:
Tabela de valores de Q_2^{+} (valores de D_2) por estado presente:
  • Para estados presentes 000,001,100,111 o próximo Q_2^{+}=1.
  • Para estados presentes 010,011,101,110 o próximo Q_2^{+}=0.
Logo, os mintermos (presentes) onde D_2=1 são: m_0,m_1,m_4,m_7 (ou seja, estados decimais 0,1,4,7).
Tabela de valores de Q_1^{+} (valores de D_1) por estado presente:
  • D_1=1 para estados presentes 001,010,110 (decimais 1,2,6). Mintermos m_1,m_2,m_6.
Tabela de valores de Q_0^{+} (valores de D_0) por estado presente:
  • D_0=1 para estados presentes 000,010,100,101,110,111 (decimais 0,2,4,5,6,7).
  • D_0=0 somente para presentes 001 e 011 (decimais 1,3).

Passo 5

Minimização e obtenção das expressões booleanas — processo e explicação (vou usar Karnaugh-maps mentalmente e mostrar o resultado com justificativa passo a passo). Primeiro, uma breve recapitulação didática sobre Karnaugh-map:
  • Um K-map para 3 variáveis organiza os 8 mintermos de forma que células adjacentes diferem em apenas uma variável. Agrupando 1s adjacentes em blocos de tamanhos potenciais 1,2,4,8 obtemos implicantes primos e simplificamos a expressão em soma de produtos. O objetivo é cobrir todos os 1s com o menor número de implicantes (preferindo blocos maiores).
Agora vamos simplificar cada função.
D0: simplificação direta (mais simples primeiro)
  • Observação rápida: D_0=1 para todos os estados exceto 001 e 011. Note que os dois estados onde D_0=0 têm em comum Q_2=0 e Q_0=1 (pois 001 e 011 têm Q_2=0 e Q_0=1 em comum). Então: D_0 = \neg (Q_2'= \text{?})\\ \text{(melhor formular)}.Mais direto: os únicos casos em que D_0=0 são Q_2=0 e Q_0=1, isto é a condição Q_2'=1 e Q_0=1 equivalem a Q_2'=Q_2=0 e Q_0=1. Em notação booleana: D_0 = \overline{\,Q_2'Q_0\,} = \overline{(\overline{Q_2}\,Q_0)}.Usando De Morgan, isso vira: D_0 = Q_2 + \overline{Q_0}.Portanto uma expressão simples e elegante é \boxed{D_0 = Q_2 + \overline{Q_0}.}(Verificação rápida: se Q_0=0 então \overline{Q_0}=1 e D_0=1; se Q_0=1 então D_0=1 só quando Q_2=1. Assim D_0=0 só quando Q_2=0 e Q_0=1, que são exatamente 001 e 011.)
D1: simplificação com grupos
  • D_1=1 em m_1(001), m_2(010), m_6(110).
  • Podemos agrupar m_2(010) e m_6(110) verticalmente (mesma coluna do K-map com Q_1=1, Q_0=0), obtendo o implicante Q_1 Q_0' (pois nessas células Q_1=1 e Q_0=0 são constantes, Q_2 varia).
  • O mintermo restante m_1(001) fica isolado e deve aparecer como produto completo Q_2' Q_1' Q_0.
  • Assim: \boxed{D_1 = Q_1 \overline{Q_0} \;+\; \overline{Q_2}\,\overline{Q_1}\,Q_0.}(Leitura: primeiro termo cobre os estados 010 e 110; o segundo termo cobre 001.)
D2: simplificação com grupos
  • D_2=1 nos mintermos m_0(000), m_1(001), m_4(100), m_7(111).
  • No K-map para 3 variáveis esses 1s podem ser cobertos por implicantes:
    • Agrupamento horizontal m_0+m_1 (linha Q_2=0, colunas 00 e 01 com Q_1=0 constante) gera o implicante \overline{Q_2}\,\overline{Q_1}.
    • Agrupamento vertical m_0+m_4 (coluna Q_1=0,Q_0=0, linhas Q_2=0 e Q_2=1) gera o implicante \overline{Q_1}\,\overline{Q_0}.
    • O mintermo m_7(111) não se agrupa bem com os outros para formar um implicante maior que o próprio, então fica como produto completo Q_2 Q_1 Q_0.
  • Colocando tudo: \boxed{D_2 = \overline{Q_2}\,\overline{Q_1} \;+\; \overline{Q_1}\,\overline{Q_0} \;+\; Q_2\,Q_1\,Q_0.}
  • Podemos fatorar um pouco o primeiro dois termos (para ter uma forma alternativa útil na implementação): D_2 = \overline{Q_1}\,(\overline{Q_2} + \overline{Q_0}) + Q_2 Q_1 Q_0.
Comentário didático sobre decisões de agrupamento:
  • Agrupamentos no K-map visam reduzir o número de literais nos produtos. Aqui obtivemos um termo triplo para cobrir m_7 que não agrupa com outros 1s, e dois implicantes de dois literais que cobrem os outros 1s. Essa é uma forma mínima (poderíamos também aceitar forma com mais produtos / literais, mas essa é compacta e direta).

Passo 6

Resumo das expressões finais e implementação lógica básica (como desenhar o circuito):
  • Expressões finais já deduzidas: \begin{aligned} D_2 &= \overline{Q_2}\,\overline{Q_1} \;+\; \overline{Q_1}\,\overline{Q_0} \;+\; Q_2\,Q_1\,Q_0,\\[4pt] D_1 &= Q_1\,\overline{Q_0} \;+\; \overline{Q_2}\,\overline{Q_1}\,Q_0,\\[4pt] D_0 &= Q_2 \;+\; \overline{Q_0}. \end{aligned}
Como implementar (descrição do desenho do circuito):
  • Ter três flip-flops do tipo D com saídas Q_2,Q_1,Q_0. As entradas são D_2,D_1,D_0 conforme as fórmulas acima.
  • Para implementar D_2:
    • Gere \overline{Q_2} e \overline{Q_1} e \overline{Q_0} com inversores.
    • Faça um AND entre \overline{Q_2} e \overline{Q_1}.
    • Faça um AND entre \overline{Q_1} e \overline{Q_0}.
    • Faça um AND de três entradas entre Q_2,Q_1,Q_0.
    • OR as três saídas AND para obter D_2.
  • Para implementar D_1:
    • Gere \overline{Q_0} e \overline{Q_2} e \overline{Q_1} conforme necessário.
    • Faça um AND entre Q_1 e \overline{Q_0}.
    • Faça um AND de três entradas entre \overline{Q_2},\overline{Q_1},Q_0.
    • OR os dois ANDs para obter D_1.
  • Para implementar D_0:
    • Gere \overline{Q_0}.
    • Faça um OR entre Q_2 e \overline{Q_0}.
  • Ligue D_2,D_1,D_0 às entradas dos flip-flops correspondentes. Todos os flip-flops compartilham o mesmo clock (bordas sincronizadas).
Portanto, o “desenho” pedido pode ser feito montando esses blocos de inversores, portas AND e OR conforme descrito — na sua prova desenhe os três FFs enfileirados, desenhe as portas que formam cada D_i e trace as conexões como acima. Se quiser otimizar, algumas portas podem ser agrupadas ou implementadas por NAND/NOR com inverters conforme tecnologia disponível.]

Passo 7

Verificações rápidas de sequência (exemplos passo a passo para dar confiança):
  • Exemplo 1: estado presente 101 (dec. 5). Então:
    • Q_2=1, Q_1=0, Q_0=1.
    • Calcular Ds: D_0 = Q_2 + \overline{Q_0} = 1 + 0 = 1 \quad(\text{OK, próximo LSB = 1})ó
D_1 = Q_1\overline{Q_0} + \overline{Q_2}\,\overline{Q_1}\,Q_0 = 0\cdot0 + 0\cdot1\cdot1 = 0
D_2 = \overline{Q_2}\,\overline{Q_1} + \overline{Q_1}\,\overline{Q_0} + Q_2Q_1Q_0 = 0\cdot1 + 1\cdot0 + 1\cdot0\cdot1 = 0
  • Logo próximo estado bits Q_2^{+}Q_1^{+}Q_0^{+} = 0\,0\,1 = 001 que é dec. 1. Corresponde à demanda 5\to1.
  • Exemplo 2: estado presente 010 (dec. 2). Aplicando as expressões obtemos próximo 011 (dec. 3) como o enunciado exige. (Você pode repetir a conta na prova para confirmar.)

Passo 8

Observações finais e alternativas (para anotar na prova e impressionar o professor):
  • Nós decidimos encaminhar os estados inválidos 4 e 7 para 5 para garantir recuperação. Isso é uma escolha proposicional — poderia-se escolher outros destinos (por exemplo mandar 4 para 0 e 7 para 1), o que mudaria algumas células da tabela e, consequentemente, as expressões finais. Em provas é importante justificar a escolha ou declarar os estados “don’t care” se o enunciado permitir otimização com don’t cares.
  • As expressões fornecidas são adequadas à implementação com portas AND, OR e NOT. Se a tecnologia exigir NAND-only ou NOR-only, converta as portas via De Morgan (é uma rotina mecânica).

Resposta

Tabela de transições (estado presente \to próximo estado), em decimal e binário:
000 \to 101
001 \to 110
010 \to 011
011 \to 000
100 \to 101
101 \to 001
110 \to 011
111 \to 101
Expressões booleanas para as entradas dos flip-flops D (com Q_2,Q_1,Q_0 estados presentes):
D_2 \;=\; \overline{Q_2}\,\overline{Q_1} \;+\; \overline{Q_1}\,\overline{Q_0} \;+\; Q_2\,Q_1\,Q_0
D_1 \;=\; Q_1\,\overline{Q_0} \;+\; \overline{Q_2}\,\overline{Q_1}\,Q_0
D_0 \;=\; Q_2 \;+\; \overline{Q_0}

Exercícios relacionados