Sistemas Digitais e Microprocessados

Latches e Flip-Flops

Professor: Gabriel Soares Baptista

Introdução

Até agora: circuitos combinacionais.

• mesma combinação de entradas → mesma saída
• nenhuma entrada anterior influencia a saída atual
• tabela-verdade descreve todo o comportamento

Hoje: circuitos que conseguem lembrar.

Base: Capítulo 5.1 a 5.10 de Sistemas Digitais: Princípios e Aplicações (Tocci, Widmer, Moss).

A Quebra Conceitual

Em circuitos sequenciais, a saída atual depende de duas coisas:

• entradas atuais
• estado armazenado anteriormente

Isso muda a pergunta de projeto.

Antes:

$$ \text{saída} = f(\text{entradas atuais}) $$

Agora:

$$ \text{saída} = f(\text{entradas atuais},\ \text{estado anterior}) $$

Quando Um Circuito Precisa Lembrar

Exemplo mental: alarme de porta.

• sensor detecta porta aberta por um instante
• depois o sensor volta ao normal
• o alarme deve continuar ligado até alguém resetar

Circuito combinacional:

• evento desaparece → saída desaparece

Circuito sequencial:

• evento desaparece → estado armazenado mantém o alarme ligado

Sistema Digital Com Memória

Leitura do diagrama:

• lógica combinacional ainda existe
• elementos de memória armazenam bits
• saídas da memória voltam para a lógica combinacional
• essa realimentação cria dependência do histórico

Pergunta Para a Aula

Circuitos combinacionais:

• sim, sempre

Circuitos sequenciais:

• não necessariamente
• o estado armazenado também entra na decisão

Saídas de Um Elemento de Memória

Um flip-flop costuma ter duas saídas complementares:

$$ Q \qquad \text{e} \qquad \overline{Q} $$

• $Q$ é a saída normal
• $\overline{Q}$ é a saída invertida
• quando dizemos que o FF está em $1$, queremos dizer $Q=1$
• quando dizemos que o FF está em $0$, queremos dizer $Q=0$

$$ \begin{array}{c|c|c} Q & \overline{Q} & \text{Estado} \\ \hline 1 & 0 & \text{setado ou armazenando }1 \\ 0 & 1 & \text{resetado ou armazenando }0 \end{array} $$

Setar, Resetar e Estado Inicial

Terminologia básica:

• setar: levar $Q$ para $1$
• resetar ou limpar: levar $Q$ para $0$

Se o circuito precisa começar em um estado específico:

• aplique reset inicial
• ou aplique preset inicial
• não dependa do acaso da energização

Latch S-R Com Portas NAND

O latch mais simples pode ser feito com duas portas NAND realimentadas.

Ideia do circuito:

• saída de uma porta volta para a entrada da outra
• essa realimentação permite manter estado
• entradas são ativas em nível BAIXO

Latch NAND: Entradas Ativas em Baixo

No latch NAND, usamos:

• $\overline{S}$: set ativo em $0$
• $\overline{R}$: reset ativo em $0$

A barra indica nível ativo baixo.

$$ \begin{array}{c|c||c} \overline{S} & \overline{R} & \text{Efeito em }Q \\ \hline 1 & 1 & \text{mantém estado anterior} \\ 0 & 1 & Q=1\ \text{set} \\ 1 & 0 & Q=0\ \text{reset} \\ 0 & 0 & \text{condição inválida} \end{array} $$

Latch NAND: Como Ler

Linha mais importante:

$$ \overline{S}=1,\ \overline{R}=1 \Rightarrow \text{mantém} $$

Isso é a memória.

Leitura por ação:

• $\overline{S}=0$ e $\overline{R}=1$ → set → $Q=1$
• $\overline{S}=1$ e $\overline{R}=0$ → reset → $Q=0$
• $\overline{S}=0$ e $\overline{R}=0$ → ação contraditória

Exemplo 1: Latch NAND

Latch NAND começa com $Q=0$.

$$ \begin{array}{c|c|c} \text{Passo} & \overline{S} & \overline{R} \\ \hline 1 & 1 & 1 \\ 2 & 0 & 1 \\ 3 & 1 & 1 \\ 4 & 1 & 0 \\ 5 & 1 & 1 \end{array} $$

Pergunta:

• qual é $Q$ após cada passo?

Exemplo 1: Resolução

• passo 1: $(1,1)$ → mantém $Q=0$
• passo 2: $(0,1)$ → set → $Q=1$
• passo 3: $(1,1)$ → mantém $Q=1$
• passo 4: $(1,0)$ → reset → $Q=0$
• passo 5: $(1,1)$ → mantém $Q=0$

Sequência final:

$$ Q: \quad 0,\ 1,\ 1,\ 0,\ 0 $$

Moral: entrada ativa muda o estado; repouso preserva o último estado válido.

Latch S-R Com Portas NOR

Também podemos construir um latch S-R com duas portas NOR realimentadas.

Diferença principal:

• latch NAND: entradas ativas em BAIXO
• latch NOR: entradas ativas em ALTO

Latch NOR: Tabela Funcional

No latch NOR, o repouso é $S=0$ e $R=0$.

$$ \begin{array}{c|c||c} S & R & \text{Efeito em }Q \\ \hline 0 & 0 & \text{mantém estado anterior} \\ 1 & 0 & Q=1\ \text{set} \\ 0 & 1 & Q=0\ \text{reset} \\ 1 & 1 & \text{condição inválida} \end{array} $$

Leitura:

• $S=1$ seta
• $R=1$ reseta
• $S=R=1$ pede duas ações incompatíveis

NAND × NOR

Pergunta correta:

esta entrada é ativa em nível alto ou baixo?

Por Que Usar Clock?

Latches mudam assim que uma entrada ativa aparece.

Isso pode ser ruim em sistemas maiores:

• sinais chegam em tempos diferentes
• atrasos de portas não são idênticos
• uma saída pode mudar em instante indesejado

Solução em sistemas síncronos:

• usar um sinal de clock
• controlar exatamente quando o estado pode mudar

Pulsos Digitais

Termos importantes:

• pulso positivo: ativo em nível ALTO
• pulso negativo: ativo em nível BAIXO
• borda de subida: $0 \rightarrow 1$
• borda de descida: $1 \rightarrow 0$
• largura do pulso: duração do nível ativo

Clock

Um clock é um trem periódico de pulsos.

Período:

$$ T = \text{tempo de um ciclo completo} $$

Frequência:

$$ f = \frac{1}{T} $$

Em sistemas síncronos:

• as entradas de controle dizem o que deve acontecer
• o clock diz quando a mudança pode acontecer

Setup e Hold

<img src="../static/tocci_fig_5_18_setup_hold.png" width=50%" style="display: block; margin: 0 auto;">

Para um flip-flop responder de forma confiável:

• entrada precisa estar estável antes da borda ativa
• entrada precisa continuar estável depois da borda ativa

Termos:

• $t_S$: tempo de setup
• $t_H$: tempo de hold

Flip-Flop S-R Com Clock

Versão sincronizada do latch S-R.

Ideia:

• $S$ e $R$ indicam a ação desejada
• $CLK$ determina quando a ação ocorre
• entradas só afetam $Q$ na borda ativa

FF S-R: Tabela Funcional

Considerando disparo na borda de subida:

$$ \begin{array}{c|c|c||c} S & R & CLK & Q^+ \\ \hline 0 & 0 & \uparrow & Q_0 \\ 1 & 0 & \uparrow & 1 \\ 0 & 1 & \uparrow & 0 \\ 1 & 1 & \uparrow & \text{ambíguo} \end{array} $$

Onde:

• $Q_0$ é o estado anterior
• $Q^+$ é o novo estado após a borda
• $\uparrow$ indica borda de subida

FF S-R: Leitura Didática

Importante:

• $S=1$, $R=0$ não seta imediatamente
• deixa o flip-flop preparado para setar
• a mudança só ocorre na borda ativa de $CLK$

Problema mantido do S-R:

$$ S=R=1 \Rightarrow \text{condição ambígua} $$

O S-R é didático, mas não é o mais versátil.

Exemplo 2: FF S-R

FF S-R disparado na borda de subida começa com $Q=0$.

$$ \begin{array}{c|c|c} \text{Borda} & S & R \\ \hline 1 & 0 & 0 \\ 2 & 1 & 0 \\ 3 & 1 & 0 \\ 4 & 0 & 1 \end{array} $$

Resolução:

• borda 1: mantém $Q=0$
• borda 2: set → $Q=1$
• borda 3: set novamente → $Q=1$
• borda 4: reset → $Q=0$

$$ Q: \quad 0,\ 1,\ 1,\ 0 $$

Flip-Flop J-K

O J-K resolve a condição ambígua do S-R.

Semelhança:

• $J$ funciona como set
• $K$ funciona como reset

Diferença:

• $J=K=1$ não é inválido
• nessa condição o FF comuta

FF J-K: Tabela Funcional

Considerando borda de subida:

$$ \begin{array}{c|c|c||c} J & K & CLK & Q^+ \\ \hline 0 & 0 & \uparrow & Q_0 \\ 1 & 0 & \uparrow & 1 \\ 0 & 1 & \uparrow & 0 \\ 1 & 1 & \uparrow & \overline{Q_0} \end{array} $$

Última linha:

• se $Q_0=0$, então $Q^+=1$
• se $Q_0=1$, então $Q^+=0$

Essa operação é chamada toggle ou comutação.

Por Que o J-K É Importante?

Com $J=K=1$:

• cada borda ativa inverte $Q$
• $Q$ alterna entre $0$ e $1$
• isso é base para contadores binários

Comparação rápida:

• S-R: tem condição ambígua
• J-K: reaproveita essa condição como comutação

Exemplo 3: Modo Toggle

FF J-K começa com $Q=0$.

Entradas fixas:

$$ J=1, \qquad K=1 $$

Como $J=K=1$, cada borda inverte o estado.

$$ \begin{array}{c|c|c} \text{Borda} & \text{Estado anterior} & \text{Novo estado} \\ \hline 1 & 0 & 1 \\ 2 & 1 & 0 \\ 3 & 0 & 1 \\ 4 & 1 & 0 \end{array} $$

Sequência:

$$ Q: \quad 1,\ 0,\ 1,\ 0 $$

Flip-Flop D

O flip-flop D é o mais direto para armazenar dados.

Ideia:

• uma entrada de controle: $D$
• na borda ativa, $Q$ recebe o valor de $D$
• depois, $Q$ mantém esse valor até a próxima borda ativa

FF D: Tabela Funcional

Considerando borda de subida:

$$ \begin{array}{c|c||c} D & CLK & Q^+ \\ \hline 0 & \uparrow & 0 \\ 1 & \uparrow & 1 \end{array} $$

Leitura prática:

• o FF D amostra $D$ em um instante específico
• $D$ pode mudar entre bordas sem alterar $Q$
• $D$ e $Q$ não são o mesmo sinal

Latch D Transparente

O latch D também armazena dados, mas não é disparado por borda.

Diferença principal:

• FF D: sensível à borda do clock
• latch D: sensível ao nível de habilitação $EN$

Latch D: Tabela Funcional

$$ \begin{array}{c|c||c} EN & D & Q^+ \\ \hline 0 & X & Q_0 \\ 1 & 0 & 0 \\ 1 & 1 & 1 \end{array} $$

Quando $EN=1$:

• latch está transparente
• $Q$ acompanha $D$

Quando $EN=0$:

• latch fecha
• $Q$ mantém o último valor armazenado

Latch D: Formas de Onda

Leitura:

• regiões cinzas: $EN=1$
• nessas regiões, $Q=D$
• fora delas, $Q$ mantém o valor anterior

Exemplo 4: FF D × Latch D

Situação:

• $Q$ começa em $0$
• $D$ vai para $1$
• antes da próxima borda, $D$ volta para $0$

Flip-flop D:

• só olha $D$ na borda ativa
• se na borda $D=0$, armazena $0$
• a passagem temporária por $1$ não é capturada

Latch D com $EN=1$:

• $Q$ acompanha $D$
• vai para $1$ enquanto $D=1$
• volta para $0$ quando $D=0$

Entradas Síncronas e Assíncronas

Entradas síncronas:

• $S$, $R$, $J$, $K$, $D$
• só afetam $Q$ junto com a borda ativa do clock

Entradas assíncronas:

• atuam independentemente do clock
• forçam um estado imediatamente

Mais comuns:

• $PRE$: preset → força $Q=1$
• $CLR$: clear → força $Q=0$

Entradas Assíncronas

Muitos CIs usam entradas assíncronas ativas em nível BAIXO:

• $\overline{PRE}$
• $\overline{CLR}$

Bolinha no símbolo:

• indica ativação em nível baixo

Tabela Essencial de PRE e CLR

Entradas assíncronas ativas em nível BAIXO:

$$ \begin{array}{c|c||c} \overline{PRE} & \overline{CLR} & \text{Efeito em }Q \\ \hline 1 & 1 & \text{operação síncrona normal} \\ 0 & 1 & Q=1\ \text{imediatamente} \\ 1 & 0 & Q=0\ \text{imediatamente} \\ 0 & 0 & \text{condição inválida} \end{array} $$

Palavra-chave:

imediatamente.

Não espera borda de clock.

Exemplo 5: Clear Assíncrono

FF J-K com entradas assíncronas ativas em baixo.

Estado inicial:

$$ Q=1,\quad J=1,\quad K=1,\quad \overline{PRE}=1,\quad \overline{CLR}=1 $$

Agora $\overline{CLR}$ vai momentaneamente para $0$.

Resultado:

• $\overline{CLR}=0$ ativa clear
• $Q$ vai imediatamente para $0$
• $J$, $K$ e $CLK$ não importam enquanto clear está ativo
• quando $\overline{CLR}$ volta para $1$, a operação síncrona normal retorna

Não Confunda PRE/CLR Com Dados

Usos típicos:

• inicialização do circuito
• reset global
• forçar estado seguro
• controle emergencial de estado

Se $\overline{CLR}=0$:

• $Q=0$ imediatamente
• clock não consegue alterar $Q$

Comparação Final

$$ \begin{array}{c|c|c|c} \text{Dispositivo} & \text{Disparo} & \text{Entrada} & \text{Ideia central} \\ \hline \text{Latch NAND S-R} & \text{nível} & \overline{S},\overline{R} & \text{ativos em }0 \\ \text{Latch NOR S-R} & \text{nível} & S,R & \text{ativos em }1 \\ \text{FF S-R} & \text{borda} & S,R & \text{set/reset sincronizados} \\ \text{FF J-K} & \text{borda} & J,K & \text{S-R com toggle} \\ \text{FF D} & \text{borda} & D & \text{armazena }D \\ \text{Latch D} & \text{nível} & D,EN & \text{transparente com }EN=1 \end{array} $$

Próximos Passos

• Usar esses blocos para construir registradores e contadores