Flip-Flops e Latches
Vídeo da aula estará disponível em breve
Circuitos sequenciais vs. combinacionais
Até agora, estudamos circuitos combinacionais: a saída depende exclusivamente das entradas atuais. Circuitos sequenciais introduzem um conceito fundamental — memória. A saída depende das entradas atuais e do estado anterior do circuito.
Comparação
Combinacional:
Saída = f(entradas atuais)
Sem memória. Sem clock. Sem estado.
Exemplos: MUX, somador, decodificador
Sequencial:
Saída = f(entradas atuais, estado anterior)
Tem memória. Pode ter clock. Tem estado.
Exemplos: contadores, registradores, CPU
A unidade básica de memória é o latch/flip-flop:
armazena 1 bit de informação.Latch SR (Set-Reset)
O latch SR é o elemento de memória mais simples. Pode ser construído com duas portas NOR ou duas portas NAND em realimentação cruzada.
Latch SR com NOR
Circuito:
R ──┤NOR├──┬── Q
┌─────┘
└──┤NOR├──┬── Q̅
S ──────┘ │
┌─────────┘
└─── (realimenta o primeiro NOR)
Tabela de operação:
S R │ Q(next) │ Operação
─────┼──────────┼────────────────
0 0 │ Q(prev) │ Mantém (memória)
0 1 │ 0 │ Reset
1 0 │ 1 │ Set
1 1 │ inválido │ PROIBIDO!
Por que S=R=1 é proibido?
Ambas saídas vão para 0 (Q=0, Q̅=0), violando Q̅ = NOT Q.
Quando ambos voltam a 0 simultaneamente, o resultado
é indeterminado — depende de qual porta é mais rápida.
Isso é uma CONDIÇÃO DE CORRIDA.
Condição proibida
A condição S=R=1 no latch SR gera um estado metaestável. Em hardware real, isso pode causar oscilação ou um valor indeterminado. O latch D foi inventado precisamente para eliminar essa possibilidade.
Latch SR com habilitação (Gated SR)
Adicionamos uma entrada Enable (E) que controla quando o latch pode mudar de estado. Quando E=0, as entradas S e R são ignoradas:
Gated SR Latch
S ──┤AND├──┐
E ──┘ ├── Latch SR ── Q
R ──┤AND├──┘
E ──┘ Q̅
E S R │ Q(next)
────────┼──────────
0 X X │ Q(prev) ← Enable = 0: mantém
1 0 0 │ Q(prev) ← sem mudança
1 0 1 │ 0 ← reset
1 1 0 │ 1 ← set
1 1 1 │ inválido ← ainda proibido!Latch D (Data)
O latch D elimina a condição proibida conectando R = NOT S. Assim, S e R nunca podem ser iguais a 1 simultaneamente. A única entrada de dados é D:
Latch D
Circuito:
D ──────┤AND├──┐
E ──┬───┘ ├── Latch SR ── Q
│ │
D̅ ──┤──┤AND├──┘
└───┘ Q̅
Tabela:
E D │ Q(next)
─────┼──────────
0 X │ Q(prev) ← transparente: mantém
1 0 │ 0 ← captura D=0
1 1 │ 1 ← captura D=1
Quando E=1: Q segue D (transparente)
Quando E=0: Q mantém o último valor de D
Comportamento nível-sensível (level-sensitive):
Q muda sempre que E está alto e D muda.
Diagrama de tempo:
E: ____████████________████████____
D: __████____████__████____████____
Q: ____████______██████____████____
↑ captura ↑mantém ↑capturaFlip-Flop D (edge-triggered)
O flip-flop D captura o valor de D apenas na borda (transição) do clock, não durante todo o nível alto. Isso é crucial para circuitos síncronos onde todos os elementos devem atualizar simultaneamente.
Flip-Flop D — borda de subida
Implementação: dois latches D em série (master-slave)
D ──┤Latch D├──┤Latch D├── Q
Master Slave
E=CLK̅ E=CLK
Quando CLK=0: Master captura D, Slave mantém
Quando CLK=1: Master mantém, Slave captura saída do Master
Resultado: Q atualiza na borda de subida (0→1) do CLK
Tabela característica:
CLK D │ Q(next)
─────────┼──────────
↑ 0 │ 0
↑ 1 │ 1
outro X │ Q(prev)
↑ = borda de subida (positive edge)
Equação característica: Q(next) = D
Diagrama de tempo:
CLK: _│‾│_│‾│_│‾│_│‾│_│‾│_
D: ‾‾‾│___│‾‾‾‾‾│___│‾‾‾
Q: ___│‾‾‾‾‾‾‾‾‾│_______
↑ ↑
captura captura
D=1 D=0
Latch vs. Flip-Flop
A diferença crucial: latch é nível-sensível (level-sensitive) — a saída muda enquanto o enable está ativo. Flip-flop é borda-sensível (edge-triggered) — a saída muda apenas no instante da transição do clock. Processadores modernos usam flip-flops para garantir que todas as atualizações aconteçam de forma síncrona e previsível.
Flip-Flop JK
O flip-flop JK é a versão melhorada do SR: quando J=K=1, em vez de ser proibido, o flip-flop inverte (toggle) seu estado.
Flip-Flop JK
Tabela característica:
J K │ Q(next) │ Operação
─────┼────────────┼────────────
0 0 │ Q(prev) │ Mantém
0 1 │ 0 │ Reset
1 0 │ 1 │ Set
1 1 │ Q̅(prev) │ Toggle (inverte!)
Equação característica:
Q(next) = J·Q̅ + K̅·Q
O JK é o flip-flop mais versátil:
- Modo D: conecte K = J̅
- Modo T: conecte J = K = T
- Modo SR: use J = S, K = R (sem estado proibido)Flip-Flop T (Toggle)
O flip-flop T é o mais simples para contadores. Quando T=1, inverte o estado; quando T=0, mantém.
Flip-Flop T
Tabela característica:
T │ Q(next)
──┼──────────
0 │ Q(prev) ← mantém
1 │ Q̅(prev) ← inverte
Equação: Q(next) = T ⊕ Q
Implementação: flip-flop JK com J = K = T
Ou: flip-flop D com D = T ⊕ Q
Uso principal: divisor de frequência e contadores.
Se T=1 permanentemente, Q oscila na metade
da frequência do clock (divide por 2).Parâmetros de timing
Restrições temporais
Setup time (tₛᵤ): tempo mínimo que D deve estar estável
ANTES da borda do clock.
Hold time (tₕ): tempo mínimo que D deve estar estável
DEPOIS da borda do clock.
D estável │ D estável
────────────┼──────────
tₛᵤ │ tₕ
↑
borda do clock
Propagation delay (tₚ): tempo entre a borda do clock
e a saída Q estabilizar.
Violar tₛᵤ ou tₕ causa METAESTABILIDADE:
Q pode ficar entre 0 e 1 por tempo indeterminado,
potencialmente causando falhas em cascata.
Frequência máxima do clock:
f_max = 1 / (tₚ + tₛᵤ + atraso_combinacional)No harness.os
Flip-flops e latches são a fundação de conceitos que aparecem em todo o stack:
- Estado e memória — um flip-flop armazena 1 bit de estado. No harness, cada campo de status (projeto ativo, sessão em andamento, feature flag ativa) é conceitualmente um flip-flop: um bit de estado que muda em momentos definidos.
- Edge-triggered vs. level-sensitive — no harness, existem dois modelos de atualização: webhooks (edge-triggered — reagem a um evento pontual) e polling (level-sensitive — verificam continuamente o estado). A maioria dos sistemas modernos prefere webhooks pelo mesmo motivo que processadores preferem flip-flops: previsibilidade.
- Setup/hold e race conditions — em software distribuído, se dois processos tentam atualizar o mesmo dado simultaneamente, há uma condição de corrida — análoga à violação de setup/hold. Locks e transações são as soluções de software para o que flip-flops resolvem em hardware.
- Clock e sincronização — o clock global do processador garante que todos os flip-flops atualizem juntos. Em sistemas distribuídos, não existe clock global — esse é um dos problemas fundamentais que o harness precisa resolver com timestamps e ordenação causal.
Exercícios
- Latch SR: Desenhe o diagrama de tempo para um latch SR com NOR dado as seguintes entradas: S=0,R=0 (Q inicial=0) → S=1,R=0 → S=0,R=0 → S=0,R=1 → S=0,R=0. Mostre Q e Q̅ a cada transição.
- Flip-flop D: Um flip-flop D com borda de subida recebe o sinal D mostrado abaixo. Desenhe a saída Q. CLK tem período de 10ns. D muda a cada 7ns começando em 0. Identifique o valor capturado a cada borda.
- Conversão: Mostre como implementar um flip-flop T usando um flip-flop D. Desenhe o circuito e prove pela tabela de excitação que o comportamento é correto.
Resumo
Verifique seu entendimento
Qual é a diferença fundamental entre um latch D e um flip-flop D?
- Circuitos sequenciais têm memória: saída depende do estado anterior
- Latch SR: set, reset, mantém e condição proibida (S=R=1)
- Latch D: elimina a condição proibida, transparente quando enable=1
- Flip-flop D: captura D apenas na borda do clock (edge-triggered)
- Flip-flop JK: versátil — set, reset, mantém e toggle
- Flip-flop T: toggle quando T=1, essencial para contadores
- Setup/hold time devem ser respeitados para evitar metaestabilidade