CIRCUITOS SEQUENCIAIS

Fundamentos de Sistemas Digitais /JUNHO/28 CIRCUITOS SEQUENCIAIS profs. Alexandre M. Amory e Fernando G. Moraes

Referências Sugiro estudarem nesta ordem de preferência: Floyd, Cap 7 até 7.4, 9,. Não tem nada de VHDL D'AMORE, Roberto. VHDL: Descrição e Síntese de Circuitos Digitais. Rio de Janeiro: LTC, 25. 259 p. Cap 6 Descrição de Circuitos Síncronos Digital Design and Computer Architecture Sec 2.9, Cap 3, 4, 5 Free Range VHDL Vahid, Cap 3 Parte referente à flip-flop e registradores PEDRONI, Volnei A. Eletrônica Digital Moderna e VHDL. Elsevier Ltda. Editora, Rio de Janeiro, RJ: 2. 69 p. Teoria: Cap e 2 VHDL: Cap 2 e 2 2

Latch PARTE I FF Mestre-Escravo 3

Circuitos Combinacionais versus Sequenciais n-inputs Combinational Circuit Combinational Circuit m-outputs (Depend only on inputs) n-inputs Combinational Circuit Next state Storage Elements m-outputs Present state Sequential Circuit 4

LATCH Um latch é um dispositivo de armazenamento temporário que tem dois estados estáveis (bi-estável) É a forma básica de memória A latch S-R (Set-Reset) é o tipo mais básico Pode ser construído a partir de portas NOR ou NAND Com portas NOR, a latch responde a entradas altas Com portas NAND, a latch responde a entradas baixa R Q S Q Notar: uma NOR com uma dada entrada em comporta-se como um inversor. 5

LATCH - NOR O latch com NOR está em uma condição estável (dado armazenado) quando ambas as entradas estão no nível lógico ZERO Assumir inicialmente S e R em. Para configurar Q =, um sinal ALTO é aplicado à entrada S enquanto o R permanece BAIXO. R S Q Q Para RESET, um sinal ALTO é aplicado à entrada R enquanto o S permanece BAIXO. R S Q Latch initially SET Q Notar: uma NOR com uma dada entrada em comporta-se como um inversor. 6

LATCH - NAND O latch com NAND está em uma condição estável (dado armazenado) quando ambas as entradas estão no nível lógico UM OU Latch initially SET Notar: uma NAND com uma dada entrada em comporta-se como um inversor. 7

FIGURE 7-3 The three modes of basic S-R latch operation (SET, RESET, no-change) and the invalid condition. 8

LATCH - NAND Latch initially SET 9

Símbolos lógicos para as latches FIGURE 7-4

Comportamento da latch

Latch com sinal de habilitação Esta latch possui uma entrada adicional, chamada de habilitação (EN) que deve estar em nível ALTO, para que a latch responda às entradas S e R FIGURE 7-8 A gated S-R latch. Uma NAND com uma dada entrada em tem em sua saída logo S/R iguais a impedindo alterações na saida Q/nQ 2

Latch com sinal de habilitação FIGURE 7-9 3

Latch D com sinal de habilitação A latch D é uma variação do latch S-R, combinando as entradas S e R em uma única entrada D FIGURE 7- A gated D latch. Uma regra simples para a latch D: Q segue D quando o EN está ativo 4

Latch D - comportamento FIGURE 7- En ativo : a saída Q é igual è entrada D Mantendo En ativo a saída acompanha a entrada D D D 5

Latch D - comportamento FIGURE 7- En ativo : a saída Q é igual è entrada D Mantendo En ativo a saída acompanha a entrada D D D 6

Latch D tabela verdade A tabela de verdade para a latch D é apresentada abaixo se EN=, a saída é igual à entrada D se EN= não há alteração na saída, e o dado está armazenado 7

Latch D uma outra implementação Latch D bit de memória para caches, por exemplo D O O2 Q ck ck 2 Inversores em série controlados por chaves ck D Q CK= saída igual à entrada D Q CK= mantém armazenado o último D lido 8

Flip-flop D Mestre-Escravo (MS) Um flip-flop MS difere de uma latch na forma como ele muda de estados Um flip-flop é um dispositivo no qual apenas a borda do relógio determina quando um novo bit é armazenado A sensibilidade à borda pode ser positiva ou negativa Indicação de sensibilidade à borda FIGURE 7-4 Operation of a positive edge-triggered D flip-flop. 9

FFD-MS: Comportamento FIGURE 7-6 2

2 Timing Latch vs FF D * Digital Design and Computer Architecture. Sec 2.9 2

22 Timing Latch vs FF D * Digital Design and Computer Architecture. Sec 2.9 22

FFD Mestre Escravo Implementação com portas lógicas Digital Logic and Microprocessor Design with VHDL (Chapter 6 Latches and Flip-Flops) 23

FFD Mestre Escravo (implementação com chaves) Implementação com utilizando chaves D O O2 Q Q Q ck ck ck ck CK= Mestre amostra e escravo mantém o estado anterior D Q CK sobe Informação transferida para a saída D Q 24

LATCH S-R EM VHDL library IEEE; use IEEE.STD_LOGIC_64.ALL; entity S_R_latch is port ( S, R : in STD_LOGIC; Q, nq : out STD_LOGIC); end S_R_latch ; architecture aof S_R_latch is signal qq, nqq: STD_LOGIC; begin qq <= R nor nqq; nqq <= S nor qq; nq <= nqq; Q <= qq; Q e notq são também entradas, logo não podem estar em uma saída end a; 25

library IEEE; use IEEE.STD_LOGIC_64.ALL; LATCH D EM VHDL entity D_latch is port ( D, ck: in STD_LOGIC; Q, nq : out STD_LOGIC); end D_latch ; architecture aof D_latch is begin process (ck, D) begin if (ck = '') then Q <= D; end if; end process; LISTA DE SENSITIVIDADE: Ativa o process quando um dos sinais da lista mudar de valor end a; 26

FLIP-FLOP D MESTRE-ESCRAVO EM VHDL library IEEE; use IEEE.STD_LOGIC_64.ALL; entity D_MS is port ( D, ck: in STD_LOGIC; Q, nq : out STD_LOGIC); end D_MS ; architecture aof D_MS is begin process (ck) begin if rising_edge(clk) then Q <= D; end if; end process; end a; rising_edge(clk) = clock 'event and clock='' LISTA DE SENSITIVIDADE: Apenas o ck na lista Note that the process block is sensitive to any change to clk value, however the rising_edge function (defined in IEEE library) checks for the value change from any value to final value of. When a change (event) on the sensitive signal occurs, the statements in the if block will be executed. 27

PARTE II Laboratório para simulação de latch e flip-flops 28

PARTE III Registradores Contadores 29

REGISTRADOR FIGURE 7-35 Example of flip-flops used in a basic register for parallel data storage. 3

REGISTRADOR registradores são basicamente sinais declarados em processos com sinal de sincronismo (exemplo: clock). para efeito de síntese e simulação, é aconselhável introduzir um reset assíncrono. process (clock, reset) begin if reset = '' then reg <= (others => ); elsif clock 'event and clock='' then reg <= barramento_a; end if; end process; -- portável; Como introduzir um sinal de enable no registrador, para habilitar a escrita? 3

REGISTRADOR Registrador com largura de palavra parametrizável, com ce : library... entity regnbit is generic(n : integer := 6); port( ck, rst, ce : in std_logic; D : in STD_LOGIC_VECTOR (N- downto ); Q : out STD_LOGIC_VECTOR (N- downto ) ); end regnbit; generic define um parâmetro do módulo architecture regn of regnbit is begin process(ck, rst) begin if rst = '' then Q <= (others => ''); elsif ck'event and ck = '' then if ce = '' then Q <= D; end if; end if; end process; end regn; Uso: rx: entity work.regnbit generic map(8) port map(ck => ck, rst => rst, ce => ce, D => D, Q => Q); 32

Simulando o Registrador reg: entity work.regnbit generic map(8) port map(ck => ck, rst => reset, ce => ce, D => D, Q => Q); reset <= '', '' after 5 ns; ck <= not ck after 2 ns; D <= x"aa", x"" after 8 ns, x"2" after 22 ns, x"3" after 24 ns, x"4" after 26 ns, x"5" after 3 ns, x"6" after 34 ns, x"7" after 36 ns, x"8" after 45 ns, x"9" after 48 ns, x"a" after 58 ns, x"b" after 7 ns, x"c" after 75 ns, x"d" after 89 ns, x"e" after 9 ns, x"f" after ns, x"" after 7 ns, x"ee" after 23 ns; ce <= ''; Time ck= ce= rst= d[7:]=a q[7:]=a ns 2 ns AA + 4 5 + 7 + 9 A B C E F EE A E F ck= entrada[3:]=3 a[3:]=3 b[3:]=2 c[3:]= rst= y[3:]= x[3:]=2 sensibilidade à borda de subida do clock 2 3 7 8 A 3 2 3 7 8 A 3 tempo de setup respeitado 2 3 7 8 A 2 3 7 8 2 5 A F 2 5 A F 2 33

REGISTRADOR DE DESLOCAMENTO exemplo de registrador de deslocamento: process (clock, reset) begin if reset = '' then A <= ; B <= ; C <= ; elsif clock'event and clock='' then A <= entrada; B <= A; C <= B; end if; end process; ) Desenhe o circuito acima utilizando flip-flops 2) A ordem das atribuições (A,B,C) é importante? O que ocorreria se fosse uma linguagem de programação tipo C? 3) Escreva o código para um registrador com deslocamento à esquerda e a direita 34

REGISTRADOR DE DESLOCAMENTO Atribuição dentro/fora de process: process (clock, reset) begin if clock'event and clock='' then A <= entrada; B <= A; Conclusão: end if; end process; X <= B + C; C <= B; Y <= B + C; -- fora do process -- dentro do process Qual a diferença de comportamento nas atribuições à X e a Y? - sinais atribuídos em processos, com controle de clock, são flip-flops/registradores. - Sinais fora de processos ou em processos sem variável de sincronismo (clock) serão sintetizados com lógica combinacional. 35

Time ck= ce= rst= ns 2 ns REGISTRADOR DE DESLOCAMENTO SIMULAÇÃO d[7:]=a q[7:]=a AA + 4 5 + 7 + 9 A B C E F EE A E F ck= entrada[3:]=3 a[3:]=3 b[3:]=2 c[3:]= rst= y[3:]= x[3:]=2 2 3 7 8 A 3 2 3 7 8 A 3 2 3 7 8 A 2 3 7 8 Registrador de deslocamento 2 5 A F 2 5 A F 2 Y: soma deslocada ciclo de clock X: soma atual process (clock, reset) begin if clock'event and clock='' then A <= entrada; B <= A; C <= B; Y <= B + C; -- dentro do process end if; end process; X <= B + C; -- fora do process 36

REGISTRADOR formas de entrada de dados FIGURE 8-2 Basic data movement in shift registers. (Four bits are used for illustration. The bits move in the direction of the arrows.) 37

REGISTRADOR carga serial 38

REGISTRADOR carga serial FIGURE 8-4 39

REGISTRADOR CARGA PARALELA E SERIAL 2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 2 2 22 23 24 25 26 27 28 29 3 3 32 33 34 library IEEE; use IEEE.STD_LOGIC_64.ALL; use IEEE.Std_Logic_unsigned. all; entity serial_in is generic(n : integer := 8); port( clk, load, reset : in std_logic; sin : in std_logic; sout : out std_logic; d : in STD_LOGIC_VECTOR (N- downto ); q : out STD_LOGIC_VECTOR (N- downto ) ); end serial_in; architecture a of serial_in is signal s: STD_LOGIC_VECTOR (N- downto ); begin process (clk, reset) begin if reset = '' then s <= (others=>''); elsif rising_edge(clk) then if load = '' then s <= d; else s <= s(n-2 downto ) & sin; end if; end if; end process; q <= s; sout <= s(n-); end a; saída paralela saída serial carga paralela carga serial 4

REGISTRADOR CARGA PARALELA E SERIAL DD <= x"aa"; sin <= ''; load <= '', '' after 3 ns, '' after 33 ns, '' after 35 ns; Time reset= clk= d[7:]=aa AA load= sin= sout= ns 2 ns 3 ns 4 ns 5 ns 6 ns carga paralela q[7:]= AA 54 A8 5 A 4 8 AA 54 A8 5 A 4 8 q[]= q[2]= q[]= q[3]= q[4]= q[5]= q[6]= q[7]= carga serial 4

CONTADOR 2 n estados entity contup is port ( end contup; clock, reset, Load, Enable: In std_logic; DATABUS : In Std_logic_Vector (5 downto ); Upcount2 : Out Std_logic_Vector (5 downto )); architecture RTL of contup is Signal Upcount : std_logic_vector (5 downto ); begin Upcount2 <= Upcount; Upcounter : Process (clock, reset) begin if reset = '' then Upcount <= ""; elsif clock'event and clock='' then if ENABLE = '' then if LOAD = '' end if; end if; end if; end process Upcounter; end RTL; then Upcount <= DATABUS; else Upcount <= Upcount + ; () Determine o comportamento deste contador, fazendo um diagrama de tempos. (2) O reset é prioritário em relação ao clock? Por quê? (3) Como modificar o contador para realizar contagem crescente/decrescente? 42

CONTADOR GRAY 2 n estados Código gray: sequência onde de um estado para outro há apenas a variação de um bit: Uma forma de implementar este código, que não apresenta uma sequência regular, é utilizar uma técnica tipo máquina de estados, onde em função do estado atual do contador, determina-se o próximo estado. architecture RTL of graycounter is signal clock, reset : std_logic;signal graycnt : std_logic_vector (2 downto ); begin gray : process (clock,reset) begin if reset = '' then graycnt <= ""; -- reset assíncrono elsif clock event and clock= then case graycnt is when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when "" => graycnt <= ""; when others => null; end case; end if; end process gray; end RTL; FIGURE 9-26 State diagram for a 3-bit Gray code counter. 43

CONTADOR Johnson 2n estados Contador JOHNSON, utilizando um registrador de deslocamento: if reset = '' then john <= ""; elsif clock event and clock= then john <= john(2 downto ) & not (john(3)); end if; -- CONCATENAÇÃO 44

EXERCÍCIO Quando o sinal de reset for, os registradores R e R2 armazenam e respectivamente. Determinar o conteúdo de R e R2 para os 6 primeiros ciclos de relógio. reset clock reset clock R (4 BITS) R2 (4 BITS) somador 4bits Descreva este circuito em VHDL port(clock, reset: in std_logic; saida : out std_logic_vector (N- downto ) ); Na arquitetura () Process para R/R2 (2) soma <= R + R2 saída Incluir: library IEEE; use IEEE.STD_LOGIC_64.ALL; use IEEE.Std_Logic_unsigned.all; 45

Time ck= ce= rst= reset d[7:]=ee clock q[7:]= reset ck=clock entrada[3:]=3 a[3:]=3 b[3:]=a c[3:]=8 rst= y[3:]=f x[3:]=2 EXERCÍCIO ns 2 ns AA R (4 BITS) + 4 5 + 7 + 9 A B C E F EE A E F R2 (4 BITS) 2 3 7 8 A 3 2 somador 4bits 3 2 7 3 8 7 A 8 3 A 2 3 7 8 2 5 A F saída 2 5 A F 2 clock= reset= r[3:]=d r2[3:]=8 saida[3:]=5 2 3 5 8 D 2 3 5 8 2 3 5 8 D 5 R: 2 3 R2: 2 Saída: 2 3 5 46

EXERCÍCIO 2 (/3) Descreva o circuito abaixo em VHDL: Um só processo para opa e opb, pois as variáveis de controle são as mesmas reset clock Contador de 8 bits opa opb somador 8bits reset clock Reg. 8 bits 8 saída port(clock, reset: in std_logic; saida : out std_logic_vector (N- downto ) ); 47

EXERCÍCIO 2 (2/3) reset clock Contador 8 bits opa opb somador 8bits reset clock Reg. 8 bits Time reset= clock= opa[7:]=7 opb[7:]=5 soma[7:]=c ns 2 ns 3 ns 2 3 4 5 6 7 + + + + 3 6 A F 5 3 6 A F 5 C 8 saída opa: 2 3 4 5 6 7 48

EXERCÍCIO 2 (descrição completa) (3/3) library IEEE; use IEEE.Std_Logic_64.all; use IEEE.Std_Logic_unsigned.all; entity exercicio2 is generic(n : integer := 8); port( clock, reset : in std_logic; saida : out STD_LOGIC_VECTOR (N- downto ) ); end exercicio2; architecture a of exercicio2 is signal opa, opb, soma: STD_LOGIC_VECTOR (N- downto ); begin Contador de 8 bits opa somador 8bits soma Reg. 8 bits opb process (clock, reset) begin if reset = '' then opa <= (others=>''); opb <= (others=>''); elsif rising_edge(clock) then opa <= opa + ; opb <= soma; end if; end process; 8 saída soma <= opa + opb saida <= soma; end a; 49

EXERCÍCIO 3 Divisor de clock Qual a saída esperada para fout? 5

PROJETO RTL Nos projetos de sistemas digitais, a descrição da operação de um circuito síncrono digital recebe o nome de RTL (do inglês Register Transfer Level) Em um projeto RTL, o comportamento do circuito é descrito em termos do fluxo de sinais, ou transferência de dados entre os registradores presentes no hardware e as operações lógicas conduzidas com estes sinais A abstração RTL é usada em linguagens de descrição de hardware como Verilog e VHDL Ferramentas de simulação lógica utilizam a descrição RTL para verificar sua funcionalidade A descrição RTL é usualmente convertida para a descrição no nível de portas lógicas por uma ferramenta de síntese lógica. O resultado da síntese representa a descrição física do circuito 5

EXEMPLO DE PROJETO RTL - CALCULADORA Calculadora tipo pilha, com estrutura das operações similar às calculadoras HP - pilha com 4 registradores de 8 bits: X, Y, Z, T Comandos controlam a operação da pilha opmode X Y 8 8 ULA 8 8 outalu high cout ov z ULA desenvolvida no TP3 Reg_D Reg_D Reg_D Reg_D Z 8 out 8 T Y T 8 8 out 8 Z X 8 Z 8 high 8 out 8 Y din Y outalu 8 8 8 out 8 X opmode opmode opmode opmode clock Registradores da pilha 52

CALCULADORA - Interface externa Opmode: código da operação Din: entrada de dados (8 bits) Saída: correspondente ao regx cout, ov, zero: qualificadores da ULA opmode din 8 CALCULADORA reset clock entity calculadora is port( reset : in std_logic; clock : in std_logic; opmode : in op_alu; ); end; din : in std_logic_vector(7 downto ); saida : out std_logic_vector(7 downto ) z, cout, ov: out std_logic 8 SAÍDA cout, ov, zero 53

CALCULADORA atividade Alterar o package da ULA acrescentando os comandos em vermelho: package p_ula is type op_alu is ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy); end p_ula; Adicionar na ULA duas operações adicionais: udec : decrementa a entrada X uclear: a saída é zero independente dos valores de X e Y X Y 8 8 opmode 8 ULA 8 cout ov z outalu high 54

CALCULADORA operação (/7) Carga de um valor externo din. A pilha desce - push Operação uload Exemplo: uload(6) X X Din 6 Y Y X 2 Z Z Y 3 2 T T Z 4 3 ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 55

CALCULADORA operação (2/7) Copiar valor de topo copia o valor de X em Y Operação: ucpx Exemplo: ucpx X X Y Y X 2 Z Z Y 3 2 T T Z 4 3 ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 56

CALCULADORA operação (3/7) Troca entre os valores de topo da pilha (X e Y), valores de Z e T não se alteram Operação: uxy Exemplo: uxy X X Y F Y Y X F Z Z 3 3 T T 4 4 ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 57

CALCULADORA operação (4/7) Pop os valores da pilha sobem Operação: uup Exemplo: uup X X Y 2 Y Y Z 2 3 Z Z T 3 4 T T 4 4 ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 58

CALCULADORA operação (5/7) Operação lógico/aritméticas com DOIS operandos Operações: uand, uor, uxor, uadd, usub Exemplo: uadd X Y X outula Y Z op 5 6 8 Z Z T 8 F T T F F ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 59

CALCULADORA operação (6/7) Operação lógico/aritméticas com UM operando Operações: uinc, uneg, udec, uclear, usll, usrl Exemplo: udec X Y X outula Y op 4 5 3 5 Z Z 8 8 T T F F ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 6

CALCULADORA operação (7/7) Multiplicação Operações: umul X Y Z X outula Y high Z outula X high Exemplo: umul 3 D 8 7 2 8 T T F F ( uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul, udec, uclear, uload, ucpx, uup, uxy ); 6

62 Exemplo de operação X Y Z T reset 2 uload, x"2" 28 2 uload, x 28" 3F 28 2 uload, x 3F" 45 3F 28 2 uload, x 45" 84 28 2 2 uadd ov= 84 84 28 2 ucpx 85 84 28 2 uinc 7B 84 28 2 uneg 84 7B 28 2 uxy 9 28 2 2 usub 28 2 2 2 uup ov= cout= D 2 2 2 umul A 2 2 2 usll AB A 2 2 uload, x AB"

Estrutura da Arquitetura da Calculadora saida <= regx; Saída da calculadora ula: entity work.alu port map(..., z=>z_int, cout=>cout_int, ov=>ov_int); ULA process(reset, clock) begin if reset='' then cout <= ''; z <= ''; ov <= ''; elsif rising_edge(clock) then if opmode=uadd or opmode=usub then cout <= cout_int; z <= z_int; ov <= ov_int; else cout <= ''; z <= ''; ov <= ''; end if; end if; end process; Registrar os flags (ADD e SUB apenas) Operação da calculadora em função do modo de operação process(reset, clock) begin if reset='' then <zerar os 4 registradores> elsif rising_edge(clock) then case opmode is <operarar de acordo com a operação exemplo: when uinc udec uneg uclear usll usrl =>... > end case; end if; end process; 63

TEST BENCH (/2) 2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 2 2 22 23 24 25 26 27 28 29 3 library IEEE; use IEEE.Std_Logic_64.all; use work.p_ula.all; entity tb is end tb; architecture tb of tb is signal cout, ov, z, reset : std_logic ; signal clock : std_logic := ''; signal saida : std_logic_vector(7 downto ); signal din : std_logic_vector(7 downto ); signal op : op_alu; type op_data is record op: op_alu; din : std_logic_vector(7 downto ); end record; type rom_op_data is array (natural range <>) of op_data; --- uand, uor, uxor, usll, usrl, uadd, usub, uinc, uneg, umul udec, uclear, uload, ucpx, uup, uxy; constant program : rom_op_data := ( (uload, x"2"), (uload, x"28"), (uload, x"3f"), (uload, x"45"), (uadd, x""), (ucpx, x""), (uinc, x""), (uneg, x""), (uxy, x""), (usub, x""), (uup, x""), (umul, x""), (usll, x""), (uload, x"ab") ); begin pacote com os operandos Tipo para o programa Vetor para receber o programa programa 64

23 24 25 26 27 28 29 3 3 32 33 34 35 36 37 38 39 4 4 42 43 44 45 46 47 48 49 5 5 52 53 54 55 56 57 uload, ucpx, uup, uxy; constant program : rom_op_data := ( (uload, x"2"), (uload, x"28"), (uload, x"3f"), (uload, x"45"), (uadd, x""), (ucpx, x""), (uinc, x""), (uneg, x""), (uxy, x""), (usub, x""), (uup, x""), (umul, x""), (usll, x""), (uload, x"ab") ); begin calc : entity work.calculadora port map(reset=>reset, clock=>clock, din=>din, opmode=>op, saida=>saida, z=>z, cout=>cout, ov=>ov); clock <= not clock after 5 ns; reset <= '', '' after 5 ns; p: process --- executa o programa begin wait for 5 ns; for i in to program'high loop din <= pr ogram(i).din; op <= pr ogram(i).op; wait for ns; end loop; wait for ns; -- delay to start the operations -- delay to finish the operations assert false -- aborta a simulação report "simulation ended" severity failure; end process; end tb; TEST BENCH (2/2) port map da calculadora Executa o programa Encerra a simulação 65

SIMULAÇÃO 4 uload enchem a pilha 66

Projeto da Calculadora Postar no Moodle um arquivo zip com: Fontes da implementação da calculadora conforme especificado COM o script de simulação PDF com teste comentado para programa diferente do test_bech fornecido Test bench em: http://www.inf.pucrs.br/moraes/fsd/vhds/tb_calc.vhd opmode din reset clock 8 CALCULADORA 8 SAÍDA cout, ov, zero 67

PARTE IV Máquina de estados finita (FSM) 68

Máquina de estados finita (FSM) Uma máquina de estados finita (FSM - do inglês Finite State Machine) ou autômato finito é um modelo matemático usado para representar programas de computadores ou circuitos lógicos O conceito é concebido como uma máquina abstrata que deve estar em um de um número finito de estados A máquina está em apenas um estado por vez, este estado é chamado de estado atual. Um estado armazena informações sobre o passado, isto é, ele reflete as mudanças desde a entrada num estado, no início do sistema, até o momento presente. Uma transição indica uma mudança de estado e é descrita por uma condição que precisa ser realizada para que a transição ocorra. Uma ação é a descrição de uma atividade que deve ser realizada num determinado momento 69

Problema FSM VHDL VHDL Solução completa em Digital Design and Computer Architecture. Sec 3.4.5 7

Tipos de FSM Moore: valor de saída depende somente do estado atual Mealy: valor de saída depende do estado atual e das entradas Digital Design and Computer Architecture 7

Tipos de FSM Moore: saída apresentada no estado, e nos arcos de transição apenas as entradas Mealy: entrada e saída apresentada nos arcos de transição Digital Design and Computer Architecture 72

Que tipo de máquina de estados é esta? Reset w = O que faz esta FSM? w = A z = B z = w = w = w = C z = w = * Fundamentals of Digital Logic with VHDL Design 73

FSM Moore LIBRARY ieee ; USE ieee.std_logic_64.all ; ENTITY moore IS PORT ( clock, resetn, w : IN STD_LOGIC ; z : OUT STD_LOGIC ) ; END moore ; 74

w = Create a user-defined signal type. State represents the state flip-flops Reset A z = w = w = C z = B z = w = w = w = 7 ARCHITECTURE Behavior OF moore IS 8 TYPE State_type IS (A, B, C) ; 9 SIGNAL State, Next_state : State_type ; BEGIN PROCESS ( Resetn, Clock ) 2 BEGIN 3 IF Resetn = '' THEN 4 State <= A ; 5 ELSIF (Clock'EVENT AND Clock = '') THEN 6 State <= Next_state; 7 END IF; 8 END PROCESS; 9 PROCESS(State,w) 2 CASE State IS 2 WHEN A => 22 IF w = '' THEN 23 Next_state <= A ; 24 ELSE Next_state <= B ; 25 END IF ; 26 WHEN B => 27 IF w = '' THEN 28 Next_state <= A ; 29 ELSE Next_state <= C ; 3 END IF ; 3 WHEN C => 32 IF w = '' THEN 33 Next_state <= A ; 34 ELSE Next_state <= C ; 35 END IF ; 36 WHEN OTHERS => Next_state <= A ; 37 END CASE ; 38 END PROCESS; 39 4 z <= '' WHEN State = C ELSE '' ; 4 END Behavior ; VHDL compiler automatically determines the correct number of state flip-flops required. - Process describes the FSM as a sequential circuit. Sensitivity list: entrada e estado atual The Case statement describes the behavior of the FSM. Each When clause represents one state in the FSM. The When clauses correspond to the states in the state diagram. Output specified. 75

Que tipo de máquina de estados é esta? O que faz esta FSM? Reset w = z = w = z = A w = z = B w = z = * Fundamentals of Digital Logic with VHDL Design 76

77 FSM Mealy LIBRARY ieee ; USE ieee.std_logic_64.all ; ENTITY mealy IS PORT ( clock, resetn, w : IN STD_LOGIC ; z : OUT STD_LOGIC ) ; END mealy ; 77

Create a user-defined signal type. State represents the state flip-flops ARCHITECTURE Behavior OF mealy IS TYPE State_type IS (A, B) ; SIGNAL State, Next_state : State_type ; BEGIN PROCESS ( Resetn, Clock ) BEGIN IF Resetn = '' THEN State <= A ; ELSIF (Clock'EVENT AND Clock = '') THEN State <= Next_state; END IF; END PROCESS; PROCESS ( State, w) BEGIN CASE State IS WHEN A => IF w = '' THEN Next_state <= A ; ELSE Next_state <= B ; END IF ; WHEN B => IF w = '' THEN Next_state <= A ; ELSE Next_state <= B ; END IF ; WHEN OTHERS => Next_state <= A; END CASE ; END PROCESS ; PROCESS ( State, w ) BEGIN CASE State IS WHEN A => z <= '' ; WHEN B => z <= w ; END CASE ; END PROCESS ; END Behavior ; Sensitivity list This Case statement describes the behavior of the FSM. Sensitivity list - Process describes the FSM as a sequential circuit. This Case statement describes the behavior of the output. 78

FSM - EXERCÍCO - MÁQUINA DE ESTADOS Desenhe a FSM equivalente Diga de que tipo é esta FSM entity FSM is port(x, clock : in std_logic; Z: out std_logic); end; architecture A of FSM is type STATES is (S, S, S2, S3); signal scurrent, snext : STATES; begin controle: process(clock, reset) begin if reset= then scurrent <= S; elsif rising_edge(clock) then scurrent <= snext; end if; end process; -- tipo enumerado combinacional: process(scurrent, X) begin case scurrent is when S => Z <= ''; if X='' then snext<=s; else snext <= S2; end if; when S => Z <= ''; if X='' then snext<=s; else snext <= S2; end if; when S2 => Z <= ''; when S3 => end case; end process; end A; if X='' then snext<=s2; else snext <= S3; end if; Z <= ''; if X='' then snext<=s3; else snext <= S; end if; 79

FSM 2 - Detector da sequência din clk rst fsm dout din dout 8

Detect input sequence rst S S S S S 8

entity fsm is port (clk: in STD_LOGIC; rst: in STD_LOGIC; din: in STD_LOGIC; dout: out STD_LOGIC); end; architecture fsm_arch of fsm is type state_type is (S, S, S, S, S); signal present_state, next_state: state_type; begin seq: process(clk, rst) begin if rst= '' then present_state <= S; elsif rising_edge(clk) then present_state <= next_state; end if; end process; 82

comb: process(present_state, din) begin case present_state is when S => if din = '' then next_state <= S; else next_state <= S; end if; when S => if din = '' then next_state <= S; else next_state <= S; end if; when S => if din = '' then next_state <= S; else next_state <= S; end if; rst S S S S next_state <= S; when S => if din = '' then else next_state <= S; end if; when S => if din = '' then next_state <= S; else next_state <= S; end if; when others => null; end case; end process; S dout <= '' when present_state = S else '' end fsm_arch; 83

Exercício Faça o test bench para o detector da sequência. rst S S S S S 84

FSM 3 Multiplicador Serial B*A A = (27) B = (5) 35 P passo 2 3 4 5 cout B n+bits A regp : n*2 bits + P + regp() Deslocamento cout regp( n*2- downto n) regp( n- downto ) A 85

FSM 3 Multiplicador Serial FSM: controle Bloco de Dados init start= start= sum shift cont= fim cont/= Deslocamento regp : n*2 bits + cout regp( n*2- downto n) regp( n- downto ) + regp() B n+bits 86

library ieee; use ieee.std_logic_64.all; entity tb is end tb; architecture a of tb is signal op, op2: std_logic_vector(3 downto ); signal produto : std_logic_vector(63 downto ); signal reset, start, end_mul : std_logic; signal clock : std_logic := ''; begin mu: entity work.mult_serial port map( clock=> clock, reset=> reset, start=>start, A => op, B=> op2, end_mul => end_mul, produto=> produto, ); reset <= '', '' after 5 ns; clock <= not clock after 5 ns; FSM 3 Multiplicador Serial http://www.inf.pucrs.br/moraes/fsd/vhds/tb_mult_serial.vhd op <= x"2345678", x"ffffffff" after 8 ns, x"2345" after 6 ns; op2 <= x"33333333", x"ffffffff" after 8 ns, x"33333333" after 6 ns; --- respostas esperadas: x3a44b2f8f2e8, xfffffffe, x3a34fffc5cbf start <= '', '' after 3 ns, '' after 5 ns, '' after 83 ns, '' after 85 ns, '' after 63 ns, '' after 65 ns; Implemente o multiplicador serial utlizando este test bench end architecture; 87

FSM 3 Multiplicador Serial op <= x"2345678", x"ffffffff" after 8 ns, x"2345" after 6 ns; op2 <= x"33333333", x"ffffffff" after 8 ns, x"33333333" after 6 ns; --- respostas esperadas: x3a44b2f8f2e8, xfffffffe, x3a34fffc5cbf start <= '', '' after 3 ns, '' after 5 ns, '' after 83 ns, '' after 85 ns, '' after 63 ns, '' after 65 ns; end architecture; Time clock= a[3:]=2345 b[3:]=33333333 start= regp[64:]=2345 end_mul= produto[63:]=3a34fffc5cbf us 2 us 3 us 2345678 FFFFFFFF 2345 33333333 FFFFFFFF 33333333 + + + + + 2345 3A44B2F8F2E8 FFFFFFFE 3A34FFFC5CBF 88

FSM 4 Árbitro de Barramento Um árbitro é um circuito que permite que um dado componente de um sistema digital (processador ou memória, por exemplo) se comunique com o barramento. Toda vez que um dado componente deseja comunicar-se com o barramento para enviar dados a outro componente, este componente deve ativar o sinal req i. Se o barramento estiver livre, o árbitro ativa o sinal grant i por um ciclo de clock, avisando ao módulo que solicitou que pode colocar dados no barramento. Ao final da transmissão, o componente que detém o barramento ativa o sinal release i por um ciclo de clock informando ao árbitro que o barramento está livre. Componente Componente Componente 2 Componente 3 BARRAMENTO ÁRBITRO req() grant() release() req() grant() release() req(2) grant(2) release(2) req(3) grant(3) release(3) BARRAMENTO contém dados, endereço, clock, reset 89

FSM 4 Árbitro de Barramento Desenhar uma máquina de estados para o árbitro Implementar o árbitro em VHDL Operação do árbitro. ficar sequencialmente lendo os sinais de solicitação (req() a req(3)). quando um dos sinais req i estiver ativo, o sinal grant i sobe por um ciclo de clock, aguardando-se que o sinal release i suba. na subida do sinal release i reinicia-se o processo de leitura sequencial, a partir do sinal req i+. Isto é feito para evitar que um dado componente seja sempre atendido em detrimento dos outros. library IEEE; use IEEE.Std_Logic_64.all; package p_arb is type control is array( to 3) of std_logic; end p_arb; library IEEE; use IEEE.STD_LOGIC_64.all; use IEEE.STD_LOGIC_unsigned.all; use work.p_arb.all; entity arbitro is port( clock, reset : in std_logic; req, release: in control; grant: out control ); end arbitro; architecture ab of arbitro is 9

Bloco de Dados Sugestão IDLE select req()= ' and req()= ' and req(2)= ' and req(3)= ' req()='' or req()='' or req(2)='' or req(3)='' architecture ab of arbitro is type state is (IDLE, SSELECT, ACK, WAITING); signal EA, PE: state; signal sel: std_logic_vector( downto ); begin process(reset, clock) begin... EA <= PE;.. end process; process(ea, req, release) begin case EA is when IDLE =>... when SSELECT =>...... end process; 2 process para máquina de estados Lâmina 75 ack waiting release(conv_integer(sel))= ' release(conv_integer(sel))='' grant(conv_integer(sel)) <= '' when EA=ACK else ''; process(reset, clock) begin if reset='' then sel <= ""; elsif rising_edge(clock) then if EA=SSELECT then if req(conv_integer(sel+))='' then sel <= sel + ;... end if; end if; end process; end ab; Registrador sel diz quem está sendo atendido 9

2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 2 2 22 23 24 25 26 27 28 29 3 3 32 33 34 35 36 37 38 39 4 4 42 FSM 4 Test bench para o árbitro library ieee; use ieee.std_logic_64.all; use work.p_arb.all; entity tb is end tb; architecture tb of tb is signal clock : std_logic := ''; signal reset : std_logic; signal req, grant, release : control; begin ab : entity work.arbitro port map ( clock => clock, reset => reset, req => req, release => release, grant => grant ); reset <= '', '' after 5 ns; clock <= not clock after 5 ns; req() <= '', '' after 8 ns, '' after 3 ns, '' after 6 ns; req() <= '', '' after 3 ns, '' after ns; req(2) <= '', '' after 3 ns, '' after ns, '' after 3 ns, '' after 6 ns; req(3) <= '', '' after 3 ns, '' after ns; modulos: for i in to 3 generate process begin release(i)<=''; wait until grant(i)=''; wait for 4 ns; release(i) <=''; wait for 2 ns; end process; end generate; end tb; Time clock= req[:3]= req[]= req[]= req[2]= req[3]= grant[:3]= grant[]= grant[]= grant[2]= grant[3]= release[:3]= release[]= release[]= release[2]= release[3]= us 8 F 7 Apenas pede U U U Todos pedem U U U U U U U 8 8 8 4 2 8 4 4 2 Gera o release 4 ns depois do grant Geração dos requests a 3 pedem http://www.inf.pucrs.br/moraes/fsd/vhds/tb_arbitro.vhd 92

FSM 5 - Transmissão de Dados Serial Considere o circuito abaixo TX, o qual implementa uma transmissão serial de dados. A linha de dados (saída do circuito) está por default em, indicando que não há transmissão de dados. O protocolo de transmissão é o seguinte:. O mundo externo ao TX (test bench) coloca um byte válido em palavra, e sobe o sinal send, indicando a TX que há dado a ser enviado para a linha. 2. No primeiro ciclo de clock após a subida de send o módulo TX sobe o sinal de busy, impedindo que o mundo externo solicite novos dados. Concorrentemente a esta ação a linha sai do repouso, indo a zero por um ciclo (bit denominado start bit). 3. Nos próximos 8 ciclos de clock o dado escrito em palavra é colocado bit a bit na linha 4. No décimo ciclo de clock após a detecção do send a linha vai a zero (stop bit) e o busy desce no final do ciclo. clock palavra send busy TX linha reset send palavra Reset clock busy linha bit7 bit6 bit5 bit4 bit3 bit2 bit bit DICA: a máquina de estados tem estados. A controle da saída linha pode ficar dentro do processo combinacional da máquina de estados. O sinal de busy pode ser implementado como uma atribuição concorrente fora dos processes. 93

Transmissão de Dados Serial Para a validação usar o test bench abaixo: library ieee; use ieee.std_logic_64.all; entity transmissor_tb is end transmissor_tb; architecture TB_ARCHITECTURE of transmissor_tb is signal busy, linha,reset, send: std_logic; signal palavra : std_logic_vector(7 downto ); signal clock : std_logic := ; begin UUT : entity work.transmissor port map (clock => clock, reset => reset, send => send, palavra => palavra, busy => busy, linha => linha ); clock <= not clock after ns; reset <= '', '' after 3 ns; send <= '', '' after 23 ns, '' after 5 ns, '' after 3 ns, '' after 32 ns; palavra <= "", "" after 3ns; end TB_ARCHITECTURE; 94

TP4 modificação do TX busy send palavra palavra send busy TX linha reset clock address 2 TX linha reset clock Linha em repouso: req grant release Linha em repouso: H O novo protocolo do transmissor é:. test bench ativa o send e disponibiliza nova palavra, desde que o busy esteja em 2. o TX ao detectar um send, ativa o sinal de req para o árbitro, e aguarda que grant suba 3. uma vez o grant ativado, sobe o busy e envia: { start bit, address(), address(), palavra(7)...palavra(), stop bit} 4. Ao enviar o stop bit ativa o release por um ciclo de clock. 95

TP4 modificação do TX busy send palavra. test bench ativa o send e disponibiliza reset nova palavra, desde que o busy esteja em clock 2. o TX ao detectar um send, ativa o sinal de address req para o árbitro, e aguarda que grant suba 3. uma vez o grant ativado, sobe o busy e envia: { start bit, address(), address(), palavra(7)...palavra(), stop bit} 4. Ao enviar o stop bit ativa o release por um ciclo de clock. 2 req TX grant linha release [] [2] [3] [4] Linha em repouso: H Ad: Palavra: x49 96

busy() send() palavra() busy() send() palavra() busy(2) send(2) palavra(2) busy(3) send(3) palavra(3) TP4 integração TXs-arbitro busy(..4) palavra(..4) send(..4) package p_arb is type control is array( to 3) of std_logic; type words is array( to 3) of std_logic_vector(7 downto ); end p_arb; reset clock address 2 TX linha reset clock address 2 TX reset TX2 reset TX3 clock clock address 2 address 2 linha linha linha Linha ( bit) reset clock ÁRBITRO req() grant() release() req() grant() release() req(2) grant(2) release(2) req(3) grant(3) release(3) 97

start stop busy(3) send(3) palavra(3) TP4 receptor Lê o dado da linha, a partir do start bit, colocando nos registradores de saída o valor do periférico que gerou o dado (endereço) e o conteúdo do dado (palavra) TX3 linha linha receptor palavra 8 reset clock endereco 2 Time reset= clock= linha=h endereco[:]=uu saida[7:]=uu word[9:]= ns 2 ns 3 ns uu uu 2 2 4 9 2 24 48 9 2 2 4 8 end = Palavra = = x2 98

TP4 unindo os blocos O test bench gera os estímulos para o transmissor (cuidando os busy), e na saída do receptor verifica-se os resultados Test bench gera os estímulos busy(..4) send(..4) palavra(..4) transmissor linha receptor palavra 8 reset clock reset clock endereco 2 99

TP4 testbench de referência 32 26 ); linha => linha 33 27 ); 2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 2 2 22 23 24 25 26 27 28 29 3 3 32 33 34 library ieee; use ieee.std_logic_64. all; use IEEE.STD_LOGIC_unsigned. all; use work.p_arb.all; entity tb is end tb; architecture tb of tb is signal clock : std_logic := ''; signal reset, linha : std_logic; signal saida: std_logic_vector(7 downto ); signal fonte: std_logic_vector( downto ); signal send, busy : control; signal palavras : words := (x"", x"2", x"3", x"4" ); begin txs : entity work.transmissores port map ( clock => clock, reset=> reset, palavras => palavras, send => send, busy => busy, linha => linha ); rxt: entity work.receptor port map( clock => clock, reset => reset, palavra => saida, endereco => fonte, linha => linha ); reset <= '', '' after 5 ns; 3 24 3 25 34 28 35 29 36 3 37 3 38 32 39 33 4 34 4 35 42 36 43 37 44 38 45 39 4 4 42 43 44 45 46 47 48 49 44 5 45 46 47 48 49 5 palavra busy => busy, saida, endereco linha => => linha fonte, rxt: entity work.receptor reset port <= map( '', '' clock after => 5 ns; clock, reset => reset, clock <= palavra not clock => after saida, 5 ns; endereco => fonte, modulos: linha for i in => to linha 3 generate process ); begin reset <= send(i)<=''; '', after 5 ns; clock <= wait not for clock 5 ns; after 5 ns; send(i)<=''; modulos: wait for until i in busy(i)=''; to 3 generate process begin send(i)<=''; wait for 5 ns; send(i)<=''; wait until busy(i)=' '; send(i)<=''; wait for 5 ns; palavras(i) <= palavras(i) + ; end process; end generate; end tb; send(i)<=''; wait for 5 ns; palavras(i) <= palavras(i) + ; end process; end generate; end tb; Cada transmissor tenta injetar um dado a cada 55 ns

TP4 simulando Time reset= clock= us 2 us TX send[]= busy[]= palavra[7:]=2 2 TX2 send[]= busy[]= palavra[7:]=22 2 2 22 23 TX3 send[2]= busy[2]= palavra[7:]=32 3 3 32 33 TX4 send[3]= busy[3]= palavra[7:]=42 4 4 42 LINHA DE DADOS linha= RECEPTOR fonte[:]=2 XXX 2 3 2 3 2 3 saida[7:]=32 uu 2 3 4 2 3 4 22 32 42 2

Projeto dos Transmissores Postar no Moodle um arquivo zip com: Projeto sem script de simulação não será avaliado! Script de simulação Fontes da implementação do projeto conforme especificado PDF com teste comentado para cenário diferente do test bench fornecido 2

PARTE V Memórias 3

4 Memória As células da memória são organizadas por colunas e linhas Uma única unidade de dados ocupa uma linha e uma série de colunas de células 8 colunas para um byte de dados 6 colunas para uma palavra de dados de 6 bits 32 colunas para uma palavra de dados de 32 bits *Floyd. Cap

5 Escrita em Memória FIGURE -6 Illustration of the write operation (Floyd).

6 Leitura em Memória FIGURE -7 Illustration of the read operation.

7 Tipos de RAM FIGURE -8 The RAM family.

8 SRAM FIGURE -9 A typical SRAM latch memory cell. FIGURE - Basic SRAM array.

9 Memória SRAM Quantos bits de endereço deve ter uma memória de 4Mx8? FIGURE - Logic diagram for an asynchronous 32k 8 SRAM.

Ciclo de Leitura e Escrita read cycle time address access time chip enable access time output enable access time, write cycle time address setup time FIGURE -3 Timing diagrams for typical read and write cycles for the SRAM in Figure -2.

SRAM em VHDL Leitura Assíncrona 2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 2 2 22 23 24 25 26 27 28 29 3 3 32 33 library IEEE; use IEEE.STD_LOGIC_64.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity RAM is generic(n: integer := 4; M: integer := 8); port( clk,we: in std_logic; adr: in std_logic_vector(n- downto ); din: in std_logic_vector(m- downto ); dout: out std_logic_vector(m- downto ) ); end entity; architecture MEM of RAM is type mem_array is array ((2**N-) downto ) of std_logic_vector(m- downto ); signal mem: mem_array; begin process(clk) begin if(rising_edge(clk)) then if we = '' then mem(conv_integer(adr)) <= din; end if; end if; end process; dout <= mem(conv_integer(adr)); end architecture;

2 DRAM FIGURE -7 A MOS DRAM cell. FIGURE -9 Simplified block diagram of a M DRAM.

3 Tipos de Memória ROM FIGURE -23 The ROM family.

4 ROM 6 x 8 bits FIGURE -25 A representation of a 6 8-bit ROM array.

5 Temporização da ROM FIGURE -29 ROM access time (t a ) from address change to data output with chip select already active.

6 ROM em VHDL

7 Combinação de ROMs FIGURE -43

8 Combinação de RAMs FIGURE -44 Illustration of word-length expansion with two 2 m n RAM s forming a 2 m 2n RAM.

9 Resumo dos tipos de memórias

2 Hierarquia de memória SRAM SRAM DRAM

2 Hierarquia de memória FIGURE -66 Changes in memory capacity and cost per unit of data as latency (access time) increases.

22 Processador Genérico Detalhes em OAC!!! * Digital Logic and Microprocessor Design With VHDL by Enoch O. Hwang