PCS 3115 (PCS2215)

Sistemas Digitais I

Módulo 16 – Latches e Flip-Flops

Prof. Dr. Marcos A. Simplicio Jr.

versão: 2.1 (Mai/2019)

 Combinatório vs. Sequencial

 Circuito combinatório: saída depende apenas

das entradas
entradas saídas
circuito
combinatório

 Circuito sequencial: saída depende de entradas

atuais e entradas passadas (memória!)
entradas saídas
circuito
combinatório próximo Elementos
estado de memória estado
atual
2
 Combinatório vs. Sequencial

 Circuito sequencial: saída depende de entradas

atuais e entradas passadas
• Circuito que armazena informações: memória
• Valor da memória em certo instante: estado

Pergunta fundamental:
Como criar um elemento de memória?!

entradas saídas
circuito
combinatório próximo Elementos
estado de memória estado
atual
3
 Elementos de Memória

 Circuito biestável mais simples

• Sem entradas: sistema se estabiliza quando energizado
• Dois estados: variável de estado Q = 0 ou 1

0 1

0
1

4
 Latch RS

 Formado por duas portas NOR R Q

S Q

R S Qt+1 Estado final

0 0 Qt Estado anterior
0 1 1 (memória!)
1 0 0
1 1 # Estado inválido
(Q = Q = 0)
 Latch RS negativo

 Formado por duas portas NAND R Q

• Ativo baixo S Q
Lógica
Negativa

Q R S Qt+1 Estado final

0 0 # Estado inválido
0 1 0 (Q = Q = 1)

1 0 1
1 1 Qt Estado anterior
Q (memória!)
 Aplicação: Circuito de Debouncing

 Problema: transição de chave mecânica

• Possível instabilidade: chave toca no contato e volta
ligeiramente, causando variação na saída…
• Ex.: contador  múltiplas contagens espúrias…
• Ex.: circuito de aceleração  vários “soquinhos”…
• Pergunta: como resolver? (dica: usar latch RS…)
Aplicação: Circuito de Debouncing
 Latch RS com Clock

 Problema: incluir uma entrada do tipo “enable”

 Latch RS com Clock

 Problema: incluir uma entrada do tipo “enable”

RS negativo

RS positivo
 Latch RS com Clock

Repouso na
C=0 S+C = R+C = 1
célula básica

S+C = S Funciona como

C=1
R+C = R Latch RS

Desvantagem: quando C = 1, ainda tem configuração

proibida nas entradas.
 Latch RS com Clock

 Ex. Carta ou Diagrama de Tempos

 Latch D

 Latch RS com clock:

• Ainda tem configuração proibida: R = S = 1 quando C = 1
• Pergunta: como eliminar configuração proibida?
• Resposta:
• 1) Podemos usar clock para manter o estado anterior: C = 0
 repouso
• 2) Se desejarmos mudar estado, podemos fazer C = 1 e:
• S = R’= 1 para fazer Q = 1 (“set”)
• R = S’= 0 para fazer Q = 0 (“reset”)
• Podemos usar uma só entrada, D = S = R’  nunca teremos
R=S!!!
 Latch D

 Clock em 1  Clock em 0
Q=D  Q(t) = Q(t-1)
 Flip-Flops: sensíveis à Borda

– Problema: ter que manter entradas constantes durante

o intervalo de atuação do sinal de controle (clock).
– Meta: estabelecer um instante preciso para armazenar
a informação.
– Borda: o instante em que um sinal digital muda de nível
lógico.
• Borda de subida (): muda de 0 para 1
• Borda de descida (): muda de 1 para 0
 Implementação:
• Circuito detector de borda
• Estrutura mestre-escravo
 Flip-Flops: detector de borda

Borda de subida Borda de descida

CLK CLK* CLK CLK*

CLK CLK
Porta de retardo Porta de retardo

CLK CLK
CLK CLK

CLK* CLK*
 Flip-Flop RS

R
Flip-Flop RS
Flip-Flop D
 Flip-Flops D: borda negativa

D(t) C D(t+1)
t+1
D Q
0  0
>C t
Q 1  1 clock

D Q
D(t) C D(t+1)
t
0  0
>C
Q clock t+1
1  1
 FF tipo com entradas assíncronas

 Entradas assíncronas: independem de clock

• Set-reset assíncronas: úteis para impor condições iniciais
• Cuidado para não ativar “set” e “reset” ao mesmo tempo!
VHDL COMPORTAMENTAL

Implementação de Latches e Flip-Flops

22
 VHDL Comportamental: processos
 Bloco contendo instruções sequenciais: process
• Embora “sequencial” para projetista, sintetizador cria
hardware concorrente...
• Bloco deve ser simples, ou hardware fica complexo e lento...
• Processos podem ser “ativados” em resposta a sinais: permite
construção de circuitos sequenciais
label: process (signal1, signal2, ... , signalN)
<variaveis_locais>
begin -- exec. sequencial
<comando_sequencial>
...
<comando_sequencial>
end process label;

Ex.: variable var; Lista de sensibilidade: processo

processos não podem declarar executa sempre que algum sinal
“sinais locais” da lista mudar de valor
23
 VHDL Comportamental: processos

 Bloco contendo instruções sequenciais: process

• Diferentes processos executam concorrentemente
• Processos executam concorrentemente com outros
comandos
label1: process (<lista_sensibilidade>)
<variaveis_locais>
1 begin -- exec. sequencial
<comandos_sequenciais> -- mantenha SIMPLES!!!
CONCORRENTES

end process label1;

label2: process (<lista_sensibilidade>)
<variaveis_locais>
2 begin -- exec. sequencial
<comandos_sequenciais> -- mantenha SIMPLES!!!
end process label2;

3 A <= B or C;
24
Ex.: Fluxo de dados vs. Comportamental
A
F
B

-- library declaration
-- library declaration library IEEE;
library IEEE; use IEEE.bit_1164.all;
use IEEE.bit_1164.all; -- entity
-- entity entity my_xor is
entity my_xor is port (A,B : in bit;
port (A,B : in bit; F : out bit);
F : out bit); end my_xor;
end my_xor; -- architecture: comportamental
-- architecture: fluxo de dados architecture behav of my_xor is
architecture dflow of my_xor is begin
begin xor_proc: process(A,B)
F <= A xor B; begin
end dflow; F <= A xor B;
end process xor_proc;
end behav;
25
Ex.: Fluxo de dados vs. Comportamental
A X = A2 + B2
quad
B Y = A2 – 2*B2

-- entity: IDÊNTICA
...
-- entity
-- architecture: comportamental
entity quad is
architecture comp of quad is
port (A,B : in integer;
begin
X,Y : out integer);
squares: process(A,B)
end quad;
variable a2,b2 : integer;
-- architecture: fluxo de dados
begin
architecture fdados of quad is
a2 := A**2;
begin
b2 := B**2;
X <= A**2 + B**2;
X <= a2 + b2;
Y <= A**2 – 2*(B**2);
b2 := 2*b2;
end fdados;
Y <= a2 - b2;
end process squares;
end comp;

26
 Processos: lista de sensibilidade

 Lista de sensitividade pode conter algumas entradas

• Ex.: saída recebe entrada só se chave “load” mudar de valor
8 8
d_in d_out
buffer
load
entity buffer is
port (load : in bit;
d_in : in bit_vector (7 downto 0);
d_out : out bit_vector (7 downto 0));
end buffer;
architecture impl of buffer is
begin
loader: process(load) -- sensível apenas a “load”
begin
d_out <= d_in; -- se load “0 → 1” ou “1 → 0”
end process loader;
end impl;
27
 Processos: atribuição condicional
if (condição) then
<expressão>
 Atribuição condicional: if elsif (condição) then
<expressão>
• Obs: parênteses é opcional
else
<expressão>
end if;

architecture arch1 of func is

 Exemplo: begin
proc: process(A,B,C)
F = A•B’•C’ + B•C begin
if (A='1' and B='0' and C='0') then
entity func is -- entity F <= '1';
port (A,B,C : in bit; elsif (B='1' and C='1') then
F : out bit); F <= '1';
end func; else -- perceba que não tem “then”
F <= '0';
end if;
end process proc;
end arch1;
28
 Processos: atribuição condicional

 Atribuição condicional: if
• Ex.: saída recebe entrada só se chave “load” mudar para 1
8 8
d_in d_out
buffer
load
entity buffer is
port (load : in bit;
d_in : in bit_vector (7 downto 0);
d_out : out bit_vector (7 downto 0));
end buffer;
architecture impl of buffer is
begin
loader: process(load) -- sensível apenas a “load”
begin -- se load “0 → 1” (borda de subida)
if (load='1') then d_out <= d_in; end if;
end process loader;
end impl;
29
 Processos: atribuição condicional
2 8
 Atribuição condicional: if ctr disp
val
 Ex.: Impressão de “P” “O” “L” “I” em display f

a h e

• P = abc’d’efg’h ; O = abcdefg’h’ ; b
g
d

• L = abc(defgh)’ ; I = (abcdefg)’h c

entity disp is
port (ctr : in bit_vector (1 downto 0);
val : out bit_vector (7 downto 0));
end disp;

architecture mydisp of disp is

...

30
 Processos: atribuição condicional
2 8
 Atribuição condicional: if ctr disp
val
 Ex.: Impressão de “P” “O” “L” “I” em display f

a h e
• P = abc’d’efg’h ; O = abcdefg’h’ ; b
g
d

• L = abc(defgh)’ ; I = (abcdefg)’h c

...
architecture mydisp of disp is
begin
printer: process(ctr)
begin
if (ctr = “00”) then val <= “11001101”; -- “P”
elsif (ctr = “01”) then val <= “11111100”; -- “O”
elsif (ctr = “10”) then val <= “11100000”; -- “L”
elsif (ctr = “11”) then val <= “00000001”; -- “I”
else val <= “00000010”; -- catch all: “-”
end if;
end process printer;
end mydisp;
31
 Processos: atribuição condicional

 Atribuição condicional com seleção: case

case <expressão_de_seleção> is
when escolhas =>
<expressões_sequenciais>
when escolhas =>
<expressões_sequenciais>
when others =>
<expressões_sequenciais>
end case;

 Exemplo: F = A•B’•C’ + B•C

entity func is -- entity

port (A,B,C : in bit;
F : out bit);
end func;

32
 Processos: atribuição condicional

 Atribuição condicional com seleção: case

 Exemplo: F = A•B’•C’ + B•C
architecture arch3 of func is
signal comboABC: bit_vector (2 downto 0);
begin
comboABC <= A & B & C; -- agrupamento de sinais para o case
process(comboABC)
begin
case (comboABC) is
when “100” => F <= ‘1’;
when “011” => F <= ‘1’;
when “111” => F <= ‘1’;
when others => F <= ‘0’;
end case;
end process func_proc;
end arch3;

33
 Processos: atribuição condicional
2 8
 Atribuição condicional com seleção: case ctr
disp
val
 Ex.: Impressão de “P” “O” “L” “I” em display f

• P = abc’d’efg’h ; O = abcdefg’h’ ;
a h e

g
b d
• L = abc(defgh)’ ; I = (abcdefg)’h c

...
architecture mydisp2 of disp is
begin
printer: process(ctr)
begin
case (ctr) is
when “00” => val <= “11001101”; -- “P”
when “01” => val <= “11111100”; -- “O”
when “10” => val <= “11100000”; -- “L”
when “11” => val <= “00000001”; -- “I”
when others => val <= “00000010”; -- catch all: “-”
end case;
end process printer;
end mydisp2;
34
 Processos: atribuição condicional
8 val
2
 Atribuição condicional com seleção: case ctr
disp 4
sol
 Ex.: Impressão de “P” “O” “L” “I” em display f

a h e
• Com “sol piscante” extra b
g
y z
d x w

...
architecture mydisp3 of disp2 is Pode haver mais
begin de um comando
printer: process(ctr) por when
begin
case (ctr) is
when “00” => val <= “11001101”; sol <= “1000”; -- “P” , x
when “01” => val <= “11111100”; sol <= “0100”; -- “O” , y
when “10” => val <= “11100000”; sol <= “0010”; -- “L” , z
when “11” => val <= “00000001”; sol <= “0001”; -- “I” , w
when others => val <= “00000010”; sol <= “0000”; -- catch all: “-”
end case;
end process printer;
end mydisp3;
35
 Processos: atribuição condicional
2 8
 Atribuição condicional com seleção: case dispE
ctr val
 Ex.: Impressão de “P” “O” “L” “I” em display
• Com sinal de habilitação (enable) enable

...
architecture archE of dispE is f

begin a h e

printer: process(ctr) b
g
d
begin
c
if (enable = ‘1’) then
case (ctr) is
when “00” => val <= “11001101”; -- “P”
when “01” => val <= “11111100”; -- “O”
when “10” => val <= “11100000”; -- “L”
when “11” => val <= “00000001”; -- “I”
when others => val <= “00000010”; -- catch all: “-”
end case;
else val <= “00000000”; -- apagado se enable desativado
end if;
end process printer;
end archE;
36
 VHDL: Latch D D Q

entity latchD is C Q
port (D, C : in bit;
Q, Q_L : out bit;
end latchD;
architecture impl of latchD is
begin
procD: process(C,D) -- lista de sensibilidade
begin
if (C='1') then -- só carrega enquanto clock = '1'
Q <= D;
Q_L <= not D;
end if;
end process procD;
end impl;

37
 VHDL: Latch D D Q

entity latchD is C Q
port (D, C : in bit;
Q, Q_L : out bit;
end latchD;
architecture impl of latchD is
signal qi : bit;
begin
procD: process(C,D) -- lista de sensibilidade
begin
if (C='1') then -- só carrega enquanto clock = '1'
qi <= D;
end if;
end process procD;
Q <= qi; -- funciona como abordagem estrutural
Q_L <= not qi;
end impl;

38
 VHDL: Flip-Flop D D Q

entity flipflopD is C Q
port (D, C : in bit;
Q, Q_L : out bit;
end flipflopD;
architecture impl of flipflopD is
signal qi : bit;
begin
procD: process(C) -- lista de sensibilidade
begin
if (C'event and C='1') then -- borda de subida do clock
qi <= D;
end if;
end process procD;
Q <= qi; -- funciona como abordagem estrutural
Q_L <= not qi;
end impl;

39
 VHDL: Flip-Flop D D Q

entity flipflopD is C Q
port (D, C : in bit;
Q, Q_L : out bit;
end flipflopD;
architecture impl of flipflopD is
signal qi : bit;
begin
procD: process(C) -- lista de sensibilidade
begin
if rising_edge(C) then -- borda de subida do clock
qi <= D;
end if;
end process procD;
Q <= qi; -- funciona como abordagem estrutural
Q_L <= not qi;
end impl;

40
 VHDL: Flip-Flop D SET

D Q
entity flipflopD is
port (D, C, set, reset: in bit; C Q
Q, Q_L : out bit;
end flipflopD ; RESET
architecture impl of flipflopD is
signal qi : bit;
begin
procD: process(C, set, reset) -- lista de sensibilidade
begin
if (set = '1') then qi <= '1'; -- assíncrono
elsif (reset = '1') then qi <= '0'; -- assíncrono
elsif rising_edge(C) then -- borda de subida do clock
qi <= D;
end if;
end process procD;
Q <= qi; -- funciona como abordagem estrutural
Q_L <= not qi;
end impl;
41
APÊNDICE

Biestáveis em VHDL: Exemplos Wakerly

42
 VHDL: Exemplos Wakerly

 Flip-flop D
(descrição estrutural)

43
 VHDL: Exemplos Wakerly

 Latch D
(descrição estrutural)

44
 VHDL: Exemplos Wakerly

 Latch D (descrição comportamental)

45
 VHDL: Exemplos Wakerly

 Flip-flop D (descrição comportamental)

46
 VHDL: Exemplos Wakerly

 CI 74x74

47
APÊNDICE

Biestáveis: detalhes adicionais

48
 Latches e Flip-Flops

 Elementos de memória mais básicos

• Armazenamento de um único bit
 Latches
• Mudança de estados depende do nível dos sinais de
entrada (“sensíveis a nível”)
• Bloco construtivo de circuitos mais sofisticados,
como Flip-Flops
 Flip-flops (FF)
• Mudança de estados na subida ou descida do sinal
de entrada (“sensíveis a borda”)
 Elementos Biestáveis

 Metaestabilidade:
• Circuito pode entrar em estado de oscilação (pouco
estável, mas possível)

0 1 1 0

0 1 1 0

PCS2012 / ETM 50
 Elementos Biestáveis

 Meta estabilidade
• Poderia permanecer nesse estado para sempre (não um
estado binário/digital)
 Comportamento Meta-estável

 Circuito altamente realimentado

• Realimentação leva o estado meta-estável para um
dos estados estáveis
 Qualquer circuito biestável é suscetível à
existência dessa meta estabilidade
 Pouca energia é suficiente para tirar do meta-
estado.
APÊNDICE

Tipos de Flip-Flops

53
Tabela Funcional por Tipo de Flip-Flop

Flip-Flop tipo T (“Toggle”) – Ação direta

Símbolo funcional Tabela funcional

S
Q Entradas Saídas
T T Q Q
Q Q Q
R
Tabela Funcional por Tipo de Flip-Flop

Flip-Flop tipo T – Sensível à borda de subida do clock

Tabela funcional
Símbolo funcional

S Entradas Saídas
T Q
T CK Q Q
CK 0 Q Q
Q
R 1 Q Q
Tabela Funcional por Tipo de Flip-Flop

Flip-Flop tipo D – Sensível à borda de subida do clock

Tabela funcional
Símbolo funcional

S Entradas Saídas
D Q
D CK Q Q
CK
Q 0 0 1
R
1 1 0
Tabela Funcional por Tipo de Flip-Flop

Flip-Flop tipo D – Sensível à borda de descida do clock

Tabela funcional
Símbolo funcional

S Entradas Saídas
D Q
D CK Q Q
CK
Q 0 0 1
R
1 1 0
Tabela Funcional por Tipo de Flip-Flop
Flip-Flop tipo JK – Sensível à borda de subida do clock

Símbolo funcional Tabela funcional

Entradas Saídas
J K CK Q Q
S
J Q 0 0 Q Q
CK 0 1 0 1
K Q
R 1 0 1 0
1 1 Q Q
Tabela Funcional por Tipo de Flip-Flop
Flip-Flop tipo JK – Sensível à borda de descida do clock

Símbolo funcional Tabela funcional

Entradas Saídas
J K CK Q Q
S
J Q 0 0 Q Q
CK 0 1 0 1
K Q
R 1 0 1 0
1 1 Q Q
APÊNDICE

Conversão entre Flip-Flops

60
 Conversão de Flip-Flops

 É possível converter um Flip-Flop em outro usando

alguma lógica adicional
• Exemplo: Flip-Flop D → Flip-Flop JK

J
Lógica Q
K D
adicional
CLK CLK Q
 Conversão de Flip-Flops

 Algumas estratégias podem ajudar a definir a lógica

adicional necessária.
 Exemplos
• Quando o número de entradas do FF alvo for maior do que o
número de entradas do FF base, pode-se usar um
multiplexador para expandir o número de entradas
• Quando a tabela funcional do FF alvo é um subconjunto da
tabela funcional do FF base, pode-se simplesmente ligar os
fios da entrada para impedir as entradas indesejadas
 Conversão de Flip-Flops

 Exemplos
• Flip-Flop tipo JK → Flip-Flop tipo D
 Conversão de Flip-Flops

 Exemplos
• Flip-Flop tipo D → Flip-Flop tipo JK
 Conversão de Flip-Flops

 Método sistemático: mapa de Karnaugh

• Determinar lógica adicional em função do valor a ser
alimentado em Y1, Y2 dados os valores de X1, X2 e Q

X1 Y1
Lógica Q
X2 adicional Y2

CLK CLK Q
 Conversão de Flip-Flops

 Método sistemático: mapa de Karnaugh para definir

lógica adicional
• Exemplo 1: Flip-Flop tipo D → Flip-Flop tipo JK
• Entradas: J, K, Q; Saída: D

JK
Q 00 01 11 10
J D 0 0 0 1 1
Lógica Q
K adicional 1 1 0 0 1
CLK CLK Q
Lógica adicional em D:
JQ + KQ
 Conversão de Flip-Flops

 Método sistemático: mapa de Karnaugh para definir

lógica adicional
• Exemplo 2: Flip-Flop tipo T → Flip-Flop tipo JK
• Entradas: J, K, Q; Saída: T

JK
Q 00 01 11 10
J T 0 0 0 1 1
Lógica Q
K adicional 1 0 1 1 0
CLK CLK Q
Lógica adicional em T:
JQ + KQ
 Conversão de Flip-Flops

 Método sistemático: mapa de Karnaugh para definir

lógica adicional
• Exemplo 3: Flip-Flop tipo JK → Flip-Flop tipo D
• Entradas: D, Q; Saídas: J, K

D
Q 0 1
J 0 0x 1x
D Lógica Q
adicional K 1 x1 x0
CLK CLK Q

Lógica adicional em JK:

J=D ; K=D