• S1 S0 = 00: Manter o estado atual.
• S1 S0 = 01: Incrementar o estado.
• S1 S0 = 10: Decrementar o estado.
• S1 S0 = 11: Carregar o estado L1L0.

• Q1+ = S1 * ~S0 * ~Q1 * Q0 + S1 * ~S0 * Q1 * ~Q0 + ~S1 * S0 * Q1 * ~Q0 + ~S1 * S0 * ~Q1 * Q0 + S1 * S0 * L1
• Q0+ = ~S1 * S0 * ~Q1 * ~Q0 + ~S1 * S0 * Q1 * Q0 + S1 * ~S0 * Q1 * Q0 + S1 * ~S0 * ~Q1 * ~Q0 + S1 * S0 * L0

graph TD;
    A[S1] --> B(Q1);
    A --> C(Q0);
    D(S0) --> B;
    D --> C;
    E[L1] --> B;
    F[L0] --> C;
    B[Flip-Flop D] --> G[Próximo Estado Q1];
    C[Flip-Flop D] --> H[Próximo Estado Q0];
    E --> G;
    F --> H;

• Flip-Flops D: Para armazenar os estados.
• Portas Lógicas (AND, OR, NOT): Para implementar as funções lógicas.

• $Q1^{+} = (S1 \cdot \sim S0 \cdot \sim Q1 \cdot Q0) + (S1 \cdot \sim S0 \cdot Q1 \cdot \sim Q0) + (\sim S1 \cdot S0 \cdot Q1 \cdot \sim Q0) + (\sim S1 \cdot S0 \cdot \sim Q1 \cdot Q0) + (S1 \cdot S0 \cdot L1)$
• $Q0^{+} = (\sim S1 \cdot S0 \cdot \sim Q1 \cdot \sim Q0) + (\sim S1 \cdot S0 \cdot Q1 \cdot Q0) + (S1 \cdot \sim S0 \cdot Q1 \cdot Q0) + (S1 \cdot \sim S0 \cdot \sim Q1 \cdot \sim Q0) + (S1 \cdot S0 \cdot L0)$

1. Entrada S1 e S0:
   • Ambas controlam o comportamento: manter, incrementar, decrementar ou carregar.
2. Flip-Flops D (Q1 e Q0):
   • Armazenam os bits de estado e recebem as entradas respectivamente das funções lógicas.
3. Portas Lógicas:
   • AND Gates: Conectadas de acordo com as equações para calcular o próximo estado.
   • OR Gates: Para combinar as saídas das expressões "AND".

Plaintext
                      +-------+
          +-----------| D-FF  |-- Q1
          |           +-------+
          |               |
          |               |
+---------|---------+------------+
| AND     | AND     | AND        |    ...
+---------|---------+---|--------+
          |             |
   +------|-------------|----------+
   | S1   | Q0          | NOT      |
          |        +----|----------+
          |        |    |
          |        +----+
        ...

     (Outras combinações de AND gates para completar as expressões)

1. Flip-Flops D (Q1 e Q0):
   • Armazenam os estados atuais e recebem entradas do mux.
2. Mux 4:1 para Q1 e Q0:
   • Seleciona entre quatro operações:
     • 00: Manter o estado atual.
     • 01: Incremento.
     • 10: Decremento.
     • 11: Carregar valores (L1 e L0).

• Operação 00 (manter): $ D_n = Q_n $ (saída é o estado atual).
• Operação 01 (incrementar): $ D_n = Q_{n+1} + 1 $ (uso de somador se necessário).
• Operação 10 (decrementar): $ D_n = Q_{n+1} - 1 $ (uso de subtrator se necessário).
• Operação 11 (carregar): $ D_n = L_n $ (carrega o valor L).

graph TD;
    A(S1) --> D1;
    A --> D2;
    B(S0) --> D1;
    B --> D2;
    L1 --> D1;
    L0 --> D2;
    Q1["Q1 (State)"] --> D1;
    Q0["Q0 (State)"] --> D2;
    S1 --|0|--> D3[Incremento];
    S0 --|1|--> D3;
    S1 --|1|--> D4[Decremento];
    S0 --|0|--> D4;
    D1[Mux 4:1] --> E1["Flip-Flop D (Q1)"];
    D2[Mux 4:1] --> E2["Flip-Flop D (Q0)"];
    E1 --> H1[Avaliar Estado Q1+];
    E2 --> H2[Avaliar Estado Q0+];

• Multiplexadores: Cada Mux terá entradas selecionadas por S1 e S0 permitindo alternar entre: manter, incrementar, decrementar, e carregar.
• Conexões Lógicas: As saídas dos muxes vão para os Flip-Flops D.

• Montagem e Simulação: Pode seguir montando esse diagrama em uma ferramenta como Deeds para simulação.
• Verificação Temporal: Teste o funcionamento conforme as operações especificadas em diferentes ciclos de clock.

• 2 Flip-Flops D: Para Q1 e Q0.
• 2 Mux 4:1: Um para cada bit (Q1 e Q0).
• Portas Lógicas (AND, OR, NOT)*: Para implementar incrementos/decrementos.
• Sinais de Controle: $S_1$, $S_0$, $L_1$, $L_0$.

1. 4:1 Mux para Q1:
   • Entrada 00: Mantém $Q1$.
   • Entrada 01: Somar 1 ao estado atual (usa lógica combinacional).
   • Entrada 10: Subtrair 1 do estado atual (usa lógica combinacional).
   • Entrada 11: Carregar $L1$.
2. 4:1 Mux para Q0:
   • Entrada 00: Mantém $Q0$.
   • Entrada 01: Somar 1 ao estado atual (usa lógica combinacional).
   • Entrada 10: Subtrair 1 do estado atual (usa lógica combinacional).
   • Entrada 11: Carregar $L0$.

1. Mux Entradas para Q1:
   • Conecte $Q1$ atual a Entrada 00.
   • Conecte incremento ao Entrada 01 (usa porta de incremento lógica).
   • Conecte decremento ao Entrada 10 (usa porta de decremento lógica).
   • Conecte $L1$ a Entrada 11.
2. Mux Entradas para Q0:
   • Conecte $Q0$ atual a Entrada 00.
   • Conecte incremento ao Entrada 01 (usa porta de incremento lógica).
   • Conecte decremento ao Entrada 10 (usa porta de decremento lógica).
   • Conecte $L0$ a Entrada 11.
3. Configuração de Sinais de Controle:
   • Sinais $S_1, S_0$ para selecionar entre as operações para ambos os Muxes.
4. Saídas dos Muxes:
   • Conecte saída de cada Mux ao respectivo Flip-Flop D.

Plaintext
       +------------+            +------------+
S1 --> | Mux Q1     | --> D1 --> | Flip-Flop  | -- Q1
S0 --> |            |            | (Q1)       |
L1 --> | Entradas   |  
       +------------+
       +------------+            +------------+
S1 --> | Mux Q0     | --> D2 --> | Flip-Flop  | -- Q0
S0 --> |            |            | (Q0)       |
L0 --> | Entradas   |  
       +------------+

1. Entrada 00: Manter o estado atual.
2. Entrada 01: Incrementar o estado atual (supondo incremento para simplificação).
3. Entrada 10: Decrementar o estado atual (supondo decremento para simplificação).
4. Entrada 11: Carregar valores ($L_1$, $L_0$).

Plaintext
       +------------------+            +------------+
Q1 --> | 00: Manter       |            |            |
       |                  |--> D1 -->  | Flip-Flop  | -- Q1
Sum1-> | 01: Incrementar  |            | (Q1)       |
Sub1-> | 10: Decrementar  |  
L1 --> | 11: Carregar     |  
       +------------------+
       +------------------+            +------------+
Q0 --> | 00: Manter       |            |            |
       |                  |--> D2 -->  | Flip-Flop  | -- Q0
Sum0-> | 01: Incrementar  |            | (Q0)       |
Sub0-> | 10: Decrementar  |  
L0 --> | 11: Carregar     |  
       +------------------+

• Entradas Mux para Q1 e Q0:
  • 00: Q1/Q0 é conectado diretamente de volta ao Mux para manter.
  • 01: Sinal de incremento conectado, que pode ser produzido via portas lógicas usando $Q$ atual.
  • 10: Sinal de decremento conectado, gerado por lógica combinacional.
  • 11: Linha de carga conecta diretamente $L1$ e $L0$ aos respectivos Muxes.
• Conexões de Controle:
  • $S_1$ e $S_0$ selecionarão qual entrada deve ser conectada à saída dos muxes, que seguem para os Flip-Flops.

1. Introdução
   • Objetivo do projeto (Projetar um contador de 2 bits programável e cascateável).
   • Explicação breve do funcionamento dos Flip-Flops D e Mux 4:1.
2. Especificação do Projeto
   • Descrição dos sinais de entrada e saída $S_1$, $S_0$, $L_1$, $L_0$, Q1, Q0, etc.
   • Tabela verdade detalhando os comportamentos para cada combinação de $S_1$ e $S_0$.
3. Diagrama de Estados
   • Apresentação e explicação do diagrama de estados para o contador.
   • Transição de estados para cada condição.
4. Tabela de Transição e Funções Lógicas
   • Tabela de próximo estado e saídas.
   • Funções lógicas para próximo estado derivadas dos Mapas de Karnaugh.
5. Projeto do Circuito
   • Descrição do circuito utilizando Flip-Flops D e multiplexadores.
   • Diagrama esquemático, incluindo conexões dos multiplexadores e Flip-Flops.
   • Explicação de como o circuito implementa o contador.
6. Implementação e Simulação
   • Procedimentos realizados para implementar o circuito no simulador (ex: Deeds).
   • Diagramas temporais adquiridos da simulação, mostrando diferentes operações (incremento, decremento, etc.).
7. Contador de 8 Bits Cascateáveis
   • Explicação de como encadear quatro módulos de 2 bits para criar um contador de 8 bits.
   • Resultados de simulação para o contador de 8 bits.
8. Cálculo de Custo
   • Análise do "Custo" do circuito em termos de quantidade de portas e componentes utilizadas.
   • Discussão sobre otimização e economia dos recursos.
9. Montagem do Circuito na Protoboard
   • Procedimento para a montagem e teste na protoboard.
   • Resultados observados em testes reais.
10. Análise de Caminhos Críticos e Frequência Máxima do Clock
    • Identificação dos caminhos críticos no circuito.
    • Cálculo da frequência máxima de operação com base nos CI utilizados.
11. Conclusão
    • Resumo do que foi aprendido no projeto.
    • Discussão sobre possíveis melhorias ou expansões futuras.
12. Referências
    • Documentos e materiais consultados para o projeto.

1. Carry Out e Carry In:
   • Cada módulo de contador de 2 bits tem saídas que representam seu estado atual, por exemplo, $Q_1$ e $Q_0$.
   • Além disso, cada módulo terá uma saída de "carry out" que é ativada quando o contador transita de seu estado máximo (por exemplo, de $11$ para $00$ no modo de incremento ou de $00$ para $11$ no modo de decremento).
   • O "carry out" de um módulo é conectado ao "carry in" do próximo módulo na cadeia (cascata).
2. Fluxo do Contador:
   • Quando o primeiro módulo atinge seu estado máximo e transita de volta ao início, ele gera um "carry out".
   • Este sinal de "carry out" ativa o incremento do próximo módulo na cadeia, efetivamente aumentando a capacidade de contagem total.
   • Este processo continua até o último módulo da cadeia.

Plaintext
Contador 2 Bits 1 (Q1, Q0) --> Carry Out 1 --+
                                               |
Contador 2 Bits 2 (Q3, Q2) <-- Carry In <-- Carry Out 2 --+
                                                           |
Contador 2 Bits 3 (Q5, Q4) <-- Carry In <-- Carry Out 3 --+
                                                           |
Contador 2 Bits 4 (Q7, Q6) <-- Carry In <-- Carry Out 4

• Cada módulo de 2 bits tem um esquema de controle S1 e S0 que, dependendo da configuração, pode ser replicado ou modificado para permitir operações específicas por módulo (por exemplo, incrementos específicos para acordar o carry_out).
• Você pode usar portas lógicas para determinar quando um módulo gera carry, normalmente quando a saída corrente é máxima.

• Quando você incrementa o primeiro módulo, ele inicialmente conta até 3 (em binário: 11) antes de gerar um carry.
• Esse carry causa um incremento no módulo seguinte e assim por diante.

1. Módulos de 2 Bits:
   • Cada bloco representa um módulo de 2 bits. Os módulos podem ser incrementados, decrementados, mantidos ou carregar um valor específico com base nos sinais de controle recebidos.
2. Entradas Lógicas:
   • Cada módulo tem entradas $L_n$, utilizadas para carregar um valor específico quando os sinais de controle $S_1$ e $S_0$ estão configurados para carregar ($11$).
3. Sinais de Controle:
   • Os sinais $S_1$ e $S_0$ controlam globalmente o comportamento dos módulos: manter, incrementar, decrementar, ou carregar.
4. Saídas do Módulo:
   • Cada módulo produz saídas como $Q_n$ e $Q_{n-1}$, que representam o estado atual do módulo de 2 bits.
   • As saídas permitem a leitura do valor de contagem acumulado ao longo dos módulos.

• Carry ou Controle Entre Módulos:
  • Conforme observado, em um projeto cascateável para contadores, cada módulo deve se conectar logicamente de tal forma que quando um módulo atinge sua capacidade máxima (em binário 11), ele gera um sinal de carry para "ativar" o próximo módulo a ser incrementado.
  • Na prática, isso se traduz em uma conexão interna que pode ser gerida via linhas de controle ou logicamente configuradas para gerenciar quando o carry deve ser repassado.
• Expansão Escalonada:
  • Essa estrutura permitida pela cascação permite a fácil expansão de 2 bits para 4, 6, 8 bits conforme necessário, simplesmente adicionando novos módulos de 2 bits ao fim da cadeia.

• Comunicação Entre Módulos:
  • Certifique-se de que a comunicação de carry é eficiente, utilizando uma lógica que leva em consideração se esta deve ser transferida entre módulos adjacentes.
• Gerenciamento de Controle:
  • $S_1$ e $S_0$ devem ser globais, controlando todos os módulos simultaneamente para operações uniformes.