Latches e Flip-Flops Abril de 2020

PCS 3115

Sistemas Digitais I

Latches e Flip-Flops

Abril de 2020

Combinatório vs. Sequencial

Circuito combinatório: saída depende apenas das entradas

Circuito sequencial: saída depende de entradas atuais e entradas passadas (memória!)

2

entradas circuito combinatório

saídas

entradas saídas

próximo estado

circuito combinatório Elementos

de memória estadoatual

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

3

entradas saídas

próximo estado

circuito combinatório Elementos

de memória estadoatual

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

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

4

0

0

1

1

Latch RS

Formado por duas portas NOR

Q

QR

S

R S Qt+1

0 0 Qt

0 1 1

1 0 0

1 1 #

Estado final

Estado anterior (memória!)

Estado inválido(Q = Q = 0)

Latch RS negativo

Formado por duas portas NAND

• Ativo baixo Q

QR

SLógica

Negativa

R S Qt+1

0 0 #

0 1 0

1 0 1

1 1 Qt

Estado final

Estado anterior (memória!)

Estado inválido(Q = Q = 1)

Q

Q

Latch RS com Clock

Problema: incluir uma entrada do tipo “enable”

Latch RS com Clock

Problema: incluir uma entrada do tipo “enable”

RS positivo

RS negativo

Latch RS com Clock

Desvantagem: quando C = 1, ainda tem configuração proibida nas entradas.

Funciona como Latch RS

S+C = S

R+C = RC = 1

Repouso na célula básica

S+C = R+C = 1C = 0

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”) • S = R’= 0 para fazer Q = 0 (“reset”)• Podemos usar uma só entrada, D = S = R’ nunca teremos

R=S!!!

Latch D

Clock em 1 Q = D

Clock em 0 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

CLK

CLK

CLK

CLK

CLK*

CLK*

CLK

CLK CLK*

Porta de retardo Porta de retardo

Borda de descida

CLK

CLK

CLK*

Borda de subida

Flip-Flop RS

R

Flip-Flop RS

Flip-Flop D

Flip-Flops D: borda negativa

D (t) C Q(t+1)

0 0

1 1

t

t+1

clock

t

t+1clock

D

> C

Q

Q

D

> C

Q

Q

D (t) C Q(t+1)

0 0

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!

Entradas Saídas

EN T Q Q

Q Q0

1 Q Q

Símbolo funcional Tabela funcional

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

EN Q

QT

S

R

Outros Tipos de Flip-Flop

Entradas

J K CK

Saídas

Q Q

Q Q0 0

0 10 1

1 01 0

Q Q1 1


J Q

Q

CK

K

S

R

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

Outros Tipos de Flip-Flop

VHDL COMPORTAMENTAL

Implementação de Latches e Flip-Flops

22

label: process (signal1, signal2, ... , signalN)<variaveis_locais>

begin -- exec. sequencial<comando_sequencial>...<comando_sequencial>

end process label;

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

23

Ex.: variable var; processos não podem declarar

“sinais locais”

Lista de sensibilidade: processo executa sempre que algum sinal

da lista mudar de valor

VHDL Comportamental: processos

Bloco contendo instruções sequenciais: process• Diferentes processos executam concorrentemente• Processos executam concorrentemente com outros

comandos

24

label1: process (<lista_sensibilidade>)<variaveis_locais>

begin -- exec. sequencial<comandos_sequenciais> -- mantenha SIMPLES!!!

end process label1;

label2: process (<lista_sensibilidade>) <variaveis_locais>

begin -- exec. sequencial<comandos_sequenciais> -- mantenha SIMPLES!!!

end process label2;

A <= B or C;

CO

NC

OR

RE

NT

ES

1

2

3

Ex.: Fluxo de dados vs. Comportamental

25

-- library declarationlibrary IEEE;use IEEE.std_logic_1164.all;-- entityentity my_xor isport (A,B : in std_logic;

F : out std_logic);end my_xor;-- architecture: fluxo de dadosarchitecture dflow of my_xor isbegin

F <= A xor B;end dflow;

-- library declarationlibrary IEEE;use IEEE.std_logic_1164.all;-- entityentity my_xor isport (A,B : in std_logic;

F : out std_logic);end my_xor;-- architecture: comportamentalarchitecture behav of my_xor isbegin

xor_proc: process(A,B)begin

F <= A xor B;end process xor_proc;

end behav;

A

BF

Ex.: Fluxo de dados vs. Comportamental

26

Aquad

B

X = A2 + B2

Y = A2 – 2*B2

-- entityentity quad isport (A,B : in integer;

X,Y : out integer);end quad;-- architecture: fluxo de dadosarchitecture fdados of quad isbegin

X <= A**2 + B**2;Y <= A**2 – 2*(B**2);

end fdados;

-- entity: IDÊNTICA...

-- architecture: comportamentalarchitecture comp of quad isbegin

squares: process(A,B) variable a2,b2 : integer;

begin a2 := A**2; b2 := B**2;X <= a2 + b2; b2 := 2*b2;Y <= a2 - b2;

end process squares;end comp;

Processos: lista de sensibilidade

Lista de sensitividade pode conter algumas entradas

• Ex.: saída recebe entrada só se chave “load” mudar de valor

27

entity buffer isport (load : in std_logic;

d_in : in std_logic_vector (7 downto 0); d_out : out std_logic_vector (7 downto 0));

end buffer;

architecture impl of buffer isbegin

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;

d_in bufferload

d_out8 8

Processos: atribuição condicional

Atribuição condicional: if• Obs: parênteses é opcional

Exemplo:

F = A•B’•C’ + B•C

28

if (condição) then <expressão>

elsif (condição) then<expressão>

else <expressão>

end if;

entity func is -- entityport (A,B,C : in std_logic;

F : out std_logic);end func;

architecture arch1 of func isbegin proc: process(A,B,C) begin if (A='1' and B='0' and C='0') then

F <= '1';elsif (B='1' and C='1') then

F <= '1';else -- perceba que não tem “then”

F <= '0';end if;

end process proc;end arch1;

VHDL: Latch D

entity latchD isport (D, C : in std_logic;

Q, Q_L : out std_logic;end latchD;

architecture impl of latchD isbegin

procD: process(C,D) -- lista de sensibilidadebegin

if (C='1') then -- só carrega enquanto clock = '1'Q <= D; Q_L <= not D;

end if;end process procD;

end impl;

29

Q

QD

C

VHDL: Latch D

entity latchD isport (D, C : in std_logic;

Q, Q_L : out std_logic;end latchD;

architecture impl of latchD issignal qi : std_logic;

beginprocD: process(C,D) -- lista de sensibilidadebegin

if (C='1') then -- só carrega enquanto clock = '1'qi <= D;

end if;end process procD;Q <= qi; -- funciona como abordagem estruturalQ_L <= not qi;

end impl;

30

Q

QD

C

VHDL: Flip-Flop D

entity flipflopD isport (D, C : in std_logic;

Q, Q_L : out std_logic;end flipflopD;

architecture impl of flipflopD is signal qi : std_logic;

beginprocD: process(C) -- lista de sensibilidadebegin

if (C'event and C='1') then -- borda de subida do clockqi <= D;


end impl;

31

Q

QD

C

VHDL: Flip-Flop D

entity flipflopD isport (D, C : in std_logic;

Q, Q_L : out std_logic;end flipflopD;


beginprocD: process(C) -- lista de sensibilidadebegin

if rising_edge(C) then -- borda de subida do clockqi <= D;


end impl;

32

Q

QD

C

VHDL: Flip-Flop D

entity flipflopD isport (D, C, set, reset: in std_logic;

Q, Q_L : out std_logic;end flipflopD ;


beginprocD: process(C, set, reset) -- lista de sensibilidadebegin 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 clockqi <= D; end if;end process procD;Q <= qi; -- funciona como abordagem estruturalQ_L <= not qi;

end impl;

33

Q

QD

C

RESET

SET

APÊNDICE

VHDL: Exemplos de atribuição condicional

34


Atribuição condicional: if• Ex.: saída recebe entrada só se chave “load” mudar para 1

35

entity buffer isport (load : in std_logic;

d_in : in std_logic_vector (7 downto 0); d_out : out std_logic_vector (7 downto 0));

end buffer;

architecture impl of buffer isbegin

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;

d_in bufferload

d_out8 8


Atribuição condicional: if Ex.: Impressão de “P” “O” “L” “I” em display

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

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

36

entity disp isport (ctr : in std_logic_vector (1 downto 0);

val : out std_logic_vector (7 downto 0));end disp;

architecture mydisp of disp is...

ctr disp2 8

val

a

b

c

d

e

f

g

h


Atribuição condicional: if Ex.: Impressão de “P” “O” “L” “I” em display



37

...architecture mydisp of disp isbegin 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;

ctr disp2 8

val

a

b

c

d

e

f

g

h


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

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

38

case <expressão_de_seleção> is when escolhas =>

<expressões_sequenciais> when escolhas =>

<expressões_sequenciais> when others =>

<expressões_sequenciais>end case;

entity func is -- entityport (A,B,C : in std_logic;

F : out std_logic);end func;


Atribuição condicional com seleção: case Exemplo: F = A•B’•C’ + B•C

39

architecture arch3 of func issignal comboABC: std_logic_vector (2 downto 0);

begincomboABC <= A & B & C; -- agrupamento de sinais para o caseprocess(comboABC)begin

case (comboABC) iswhen “100” => F <= ‘1’;when “011” => F <= ‘1’;when “111” => F <= ‘1’;when others => F <= ‘0’;

end case;end process func_proc;

end arch3;


Atribuição condicional com seleção: case Ex.: Impressão de “P” “O” “L” “I” em display



40

...architecture mydisp2 of disp isbegin 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;

a

b

c

d

e

f

g

h

ctr disp2 8

val



• Com “sol piscante” extra

41

...architecture mydisp3 of disp2 isbegin printer: process(ctr) 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;

ctr

28 val

4

soldisp

a

b

c

d

e

f

g

h

x

y z

w

Pode haver mais de um comando

por when



• Com sinal de habilitação (enable)

42

...architecture archE of dispE isbegin printer: process(ctr) begin if (enable = ‘1’) then

case (ctr) iswhen “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;

ctr dispE2 8

val

enable

a

b

c

d

e

f

g

h

APÊNDICE

Biestáveis em VHDL: Exemplos Wakerly

43

VHDL: Exemplos Wakerly

Flip-flop D (descrição estrutural)

44


Latch D (descrição estrutural)

45


Latch D (descrição comportamental)

46


Flip-flop D (descrição comportamental)

47


CI 74x74

48

APÊNDICE

Biestáveis: detalhes adicionais

49

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)

51PCS2012 / ETM

0

0

1

1

1

1 0

0

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

Aplicação de Latches para Debouncing

54

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

APÊNDICE

Outros tipos de Flip-Flop

57

Tabela Funcional por Tipo de Flip-Flop

Entradas Saídas

T Q Q

Q Q


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

Q

Q

T

S

R

Entradas Saídas

D CK Q Q

0 10

1 1 0


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

D Q

QCK

S

R



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

Entradas Saídas

D CK Q Q

0 10

1 1 0

D Q

QCK

S

R


Entradas

J K CK

Saídas

Q Q

Q Q0 0

0 10 1

1 01 0

Q Q1 1


J Q

Q

CK

K

S

R

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


APÊNDICE

Conversão entre Flip-Flops

62

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

KLógica

adicional

CLK

DQ

QCLK


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


Exemplos

• Flip-Flop tipo JK → Flip-Flop tipo D


Exemplos

• Flip-Flop tipo D → Flip-Flop tipo JK


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

Lógica adicional

CLK

Q

QCLK

X1

X2

Y1

Y2


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

Lógica adicional

CLK

Q

QCLK

J

K

D

00 01 11 10

0 0 0 1 1

1 1 0 0 1

JKQ

Lógica adicional em D: JQ + KQ



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

Lógica adicional

CLK

Q

QCLK

J

K

T

00 01 11 10

0 0 0 1 1

1 0 1 1 0

JKQ

Lógica adicional em T: JQ + KQ



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

Lógica adicional

CLK

Q

QCLK

D

0 1

0 0x 1x

1 x1 x0

DQ

Lógica adicional em JK: J=D ; K=D

J

K

Latches e Flip-Flops Abril de 2020

Documents

Transcript of Latches e Flip-Flops Abril de 2020