Projecto de Sistemas Digitais

(1)

Projecto de Sistemas Digitais

Setembro de 2007 António José Duarte Araújo

(2)

AJA, FEUP PSDI - Linguagens de descrição de hardware - Verilog 2

Linguagens de descrição de

hardware

• HDL - Hardware Description Language

• HDL ≠ linguagem de programação

– linguagem de programação (software): pode ser traduzida em instruções máquina e executada num computador

– HDL: linguagem com suporte semântico e sintáctico para modelação do comportamento temporal e estrutura espacial do

hardware

• Modelação de um circuito digital com uma HDL

– descrições comportamentais permitem nível elevado de abstracção

– metodologia top-down: ferramentas de síntese automática – representação textual: portabilidade, edição e documentação

• Modelação de um circuito digital com uma HDL

– a favor do esquemático: “uma figura diz mais do que mil palavras”

• um esquema transmite melhor a ideia estrutural

• ferramentas gráficas front-end produzem descrições em HDLs – editores de esquemático: netlist em HDL (estrutural, gate-level ou RTL) – editores de diagramas de estados: descrições sintetizáveis

– construção de um modelo: duas perspectivas • descrever o seu funcionamento apenas para simulação • construir uma descrição sintetizável

– um modelo sintetizável deve descrever “bem” o seu funcionamento

– subsets das linguagens e regras de modelação podem depender das ferramentas

Linguagens de descrição de

(3)

Modelação em HDLs: sintetizável/não

sintetizável

• Ferramentas de síntese automática inferem uma estrutura

– o modelo (comportamental ou estrutural) vai ser hardware – regras, restrições e recomendações das ferramentas de síntese

• como é interpretada e traduzida a descrição em HDL • simulação e implementação devem concordar

• construções específicas da tecnologia de implementação

• Modelos não sintetizáveis

– não são traduzidos para hardware

– exemplos: definição de estímulos para simulação; monitorização de sinais

– modelam o comportamento de outros circuitos só para simulação • circuito de relógio

• memórias ou CPUs

• circuitos de interface (por exemplo conversores A/D ou D/A)

Modelação em HDLs:

recomendações gerais

• Antes de iniciar a construção do modelo

– definir a arquitectura e estruturar o projecto (particionamento) – ferramentas de síntese não processam bem circuitos muito

grandes!

• Problemas de optimização são NP-completos

• Escrever o código de modo a reflectir a arquitectura

– estruturado em módulos e funções, ter em mente a reutilização – favorecer a legibilidade: nomes, comentários, parêntesis,

parâmetros

• Garantir a precisão da simulação

– deve traduzir fielmente o comportamento do hardware gerado – modelar correctamente o comportamento das partes não

(4)

VHDL e Verilog: comparação

– Capacidade de modelação

• semelhante para modelos estruturais

• VHDL oferece melhor suporte para modelos abstractos e modelos de atrasos • Verilog tem melhores construções para modelar ao nível lógico e primitivas de

bibliotecas de ASICs e FPGAs – Tipos de dados

• VHDL suporta tipos de dados abstractos criados pelo utilizador

• em Verilog os tipos são muito simples e mais próximos do hardware (wire e reg) – Aprendizagem

• VHDL é fortemente tipada, menos intuitiva, mais verbosa (baseada em ADA) • Verilog é mais simples e menos verbosa (baseada em C)

– Parametrização

• VHDL tem construções para parametrizar número de bits, replicar estruturas e configurar modelos

• Verilog suporta apenas modelos com parâmetros, instanciação com redefinição de parâmetros

VHDL e Verilog: exemplo

(comportamental)

library IEEE; use IEEE.STD_Logic_1164.all; entity MUX_2_1 is port(S1,A1,B1,S2,A2,B2,S3,A3,B3:in std_logic; Y1,Y2,Y3:out std_logic);

end entity MUX_2_1;

architecture COND_DATA_FLOW of MUX_2_1 is begin Y1 <= A1 when S1=‘1’ else B1; TWO_2_1_MUXES: process(S2,A2,B2,S3,A3,B3) begin Y2<=B2; if (S2=‘1’) then Y2<=A2; endif; if (S3=‘1’) then Y3<=A3; else Y3<=B3; endif; module MUX_2_1(S1,A1,B1,Y1, S2,A2,B2,Y2, S3,A3,B3,Y3); input S1,A1,B1,S2,A2,B2,S3,A3,B3; output Y1,Y2,Y3; reg Y2,Y3; assign Y1=S1?A1:B1; always @(S2 or A2 or B2 or S3 or A3 or B3) begin Y2=B2; if (S2) Y2=A2; if (S3) Y3=A3; else Y3=B3; end endmodule VHDL Verilog

(5)

VHDL e Verilog: exemplo

(estrutural)

library IEEE; use IEEE.STD_Logic_1164.all; entity HALF_ADDER is port(a,b:in std_logic; sum,carry:out std_logic); end entity HALF_ADDER;

architecture STRUCT of HALF_ADDER is component xor2

port(a,b:in std_logic; c:out std_logic); end component;

component and2

port(a,b:in std_logic; c:out std_logic); end component;

begin

X1: xor2 port map(a=>a,b=>b,c=>sum); A1: and2 port map(a=>a,b=>b,c=>carry); end STRUCT; module HALF_ADDER(a,b,sum,carry); input a,b; output sum,carry; xor X1(sum,a,b); and A1(carry,a,b); endmodule VHDL Verilog

Verilog HDL

• Modelação e simulação de circuitos digitais

• Suporta modelação em diferentes níveis de abstracção

• Possibilidade de inferir automaticamente hardware

com outras ferramentas

• Largamente difundida na comunidade de projecto de

circuitos e sistemas digitais

• Suporta organização hierárquica com uma sintaxe

simples e com fortes semelhanças à linguagem C

• Permite que o projectista descreva o que o hardware

deve fazer sem o implementar, i.e., permite separar

‘comportamento’ e ‘implementação’

(6)

Exemplo de um modelo em Verilog

Entradas Saída O(D1, D0, S0) = D1·S0 + D0·S0 AND_1 AND_2 OR_1 mux2_1

Elementos do modelo

exemplificado

interface implementação nome do bloco entradas saídas primitivas lógicas nomes das instâncias saída entradas ligações (“fios”) comentário operador de negação

(7)

Formas de modelação de circuitos

• Estrutural

modelo descrito pela interligação de blocos que compõem o circuito (como no exemplo anterior, mux2_1)

• Comportamental

modelo descrito pelo comportamento funcional que o circuito deve possuir (como nos exemplos seguintes)

Exemplos de modelos

comportamentais

‘assign’ ‘always’

(8)

Modelação de circuitos

combinacionais com ‘assign’

• A expressão exp pode conter operadores aritméticos, booleanos, relacionais, lógicos (bit a bit), etc.

• Consiste na forma mais simples e natural de modelar circuitos combinacionais

• Introduz maior abstracção que a abordagem estrutural baseada na utilização de portas lógicas

traduz uma atribuição contínua: a expressão exp é permanentemente avaliada e o resultado é continuamente atribuído a O

exp

Modelação de circuitos

combinacionais com ‘always’

lista de sensibilidades

consiste num bloco de instruções que é executado sempre que qualquer sinal presente na lista de sensibilidades sofra alteração do valor lógico

• Num bloco ‘always’ qualquer atribuição deve ser feita a variáveis declaradas como ‘reg’ (conceito de “segurar” o valor lógico)

• Um bloco ‘always’ pode conter estruturas de controlo como as usadas num programa (ciclos ‘for’, ‘while’ e ‘repeat’, ‘if-else’ e ‘case’) • Construção essencial em que se fundamenta a modelação

(9)

Modelação de circuitos

combinacionais com ‘always’

• Que acontece se um sinal não estiver na lista de sensibilidades? • O simulador ignora qualquer transição desse sinal, pelo que, pode

produzir erros nas saídas que dele dependem

Formas da lista de sensibilidades

(admissíveis no Verilog-2001)

(equivale a indicar na lista todos os sinais lidos no bloco ‘always’)

Algumas primitivas lógicas

• Podem ser usadas com mais entradas

• Primeiro sinal é a saída e os restantes são as entradas

• São os blocos básicos (primitivas) de uma descrição estrutural

inv

a1 na1

o1 no1

(10)

Constantes numéricas

8’b1011_0100

o underscore é ignorado formato de representação (d, b, o, h) decimal que indica o número de bits

Exemplos:

0100

1111111100010001 Ù

Ù

Por omissão, uma constante é um decimal (compl. para 2) com 32 bits (se atribuída a sinais com menos bits é truncada a parte mais significativa!) 4’d4 16’hff_11 reg [3:0] a; ... initial begin a = 28; // 28=11100 -> a fica com 1100=1210 ... end

Tipos de operadores

• Aritméticos

• Lógicos

• Relacionais

• Bitwise

• Redução

• Deslocamento

• Outros

Nos exemplos seguintes:

(11)

Operadores aritméticos

B**B → 0100 potência ** C%B → 0001 divisão (resto) % C/B → 0010 divisão (quociente) / A*B → 1100 multiplicação * A-B → 0100 subtracção -A+B → 1000 adição + exemplo operação símbolo

Operadores lógicos

A||B → 1, A||D → 1 ou || A&&B → 1, A&&D → 0 e && !A → 0, !D → 1 negação ! exemplos operação símbolo

(12)

Operadores relacionais

B<=C → 1, B<=D → 0 menor ou igual a <= A>=C → 0, B>=B → 1 maior ou igual a >= A<C → 0, B<D → 0 menor que < A>B → 1, B>C → 0 maior que > B!=D → 1 desigualdade != A==B → 0 igualdade == exemplos operação símbolo

Operadores bitwise

A~^C → 1100 não ou exclusivo ~^ A^C → 0011 ou exclusivo ^ A|C → 0111 ou | A&C → 0100 e & ~A → 1001 negação ~ exemplo operação símbolo

(13)

Operadores de redução

~^A → 1, ~^D → 1 não ou exclusivo ~^ ^A → 0, ^D → 0 ou exclusivo ^ ~|A → 1, ~|D → 1 não ou ~| |A → 1, |D → 0 ou | ~ &A → 0, ~ &D → 1 não e ~ & &A → 0, &D → 0 e & exemplos operação símbolo

Operadores de deslocamento

A<<1 → 1100, C<<2 → 0100 deslocamento para a esquerda << A>>1 → 0011, C>>2 → 0001 deslocamento para a direita >> exemplos operação símbolo

(14)

Outros operadores

A==B ? C : D → 0000 condicional ? : {2{A}} → 01100110 replicação { { } } {A,B} → 01100010 concatenação { } exemplo operação símbolo

Projecto de um somador completo

A B Ci Co S A B Ci Co S 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 S Co Ci B A

Co = A·B + B·Ci + A·Ci S = A B Ci+ +

circuito lógico

símbolo do

(15)

Projecto de um somador

completo: Verilog

Como verificar que um modelo realiza a função pretendida?

Elaboração de um

testbench para o full-adder

Projecto de um somador

completo: simulação

(16)

Projecto de um somador de 4 bits:

especificação

A3 Ci Co A B Ci Co S A B Ci Co S A B Ci Co S A B Ci Co S B3 S3 A2 B2 A1 B1 A0 B0 S2 S1 S0 w1 w2 w3

ou, mais simplesmente

Projecto de um somador de 4

bits: verificação funcional

Testbench: instância o módulo a testar (adder4)

`timescale 1ns/100ps module adder4_testbench; reg [3:0] a, b; reg cin; wire [3:0] s; wire cout;

adder4 DeviceUnderTest(a, b, cin, s, cout);

// adder4 DeviceUnderTest(.Ci(cin), .Co(cout), .A(a), .B(b), .S(s)); initial

begin

$monitor($time, “ ci=%b, a=%d, b=%d, s=%d, co=%b”, cin, a, b, s, cout); cin=0; a=2; b=4; #30 b=12; #30 cin=1; #30 a=4'b1110; b=4'b0110; #30 $stop; o circuito a testar monitor de sinais estímulos de simulação

registos (seguram valores !) fios (propagam valores !)

controlo do simulador (pára)

espera 30 unidades de tempo (30ns) módulo sem interface

quando o simulador inicia ...

sinais ligados por posição sinais ligados

(17)

Projecto de um somador de 4 bits:

resultados da simulação (texto)

Projecto de um somador de 4 bits:

resultados da simulação (formas de onda)

(18)

Projecto de um somador de 4 bits:

verificação funcional (cont)

Verificação exaustiva do somador de 4 bits

• e se fosse de 32 bits ? (com 1ns por vector seriam necessários 1170 anos!)

module adder4_testbench; reg [3:0] a, b; reg cin; wire [3:0] s; wire cout;

adder4 DeviceUnderTest(a, b, cin, s, cout);

initial begin

$monitor($time, “ ci=%b, a=%d, b=%d, s=%d, co=%b", cin, a, b, s, cout);

cin = 0; $display(“Verificacao com carry-in = %b”, cin);

for(a=0;a<15;a=a+1) for(b=0;b<15;b=b+1) #40;

cin = 1; $display(“Verificacao com carry-in = %b”, cin);

for(a=0;a<15;a=a+1) for(b=0;b<15;b=b+1) #40; $display(“Fim da simulação”); $stop; end

endmodule

Declaração do interface

• Um módulo pode não ter interface

– em módulos usados para teste de outros - testbenches

module myadder_testbench; // sem entradas nem saídas

• Declaração de portos de interface – unidireccionais:

input [7:0] din_a, din_b; // din_a, din_b são entradas de 8 bits // onde o MSB é din_a[7] e o LSB é din_a[0] input clock, reset; // clock, reset são entradas de 1 bit output [0:8] res; // result é uma saída de 9 bits, onde o

// MSB é res[0] e o LSB é res[8] – bidireccionais:

inout [7:0] databus; // databus é um sinal bidireccional de 8 bits: // pode forçar um nível lógico ou receber um // sinal do exterior

• Todos os sinais declarados como portos de entrada/saída são do tipo wire (fio)

– fios (wires) apenas “propagam” valores lógicos entre uma origem e um destino – as saídas que “seguram” valores lógicos devem ser declaradas como sinais do tipo reg

(19)

Declaração de sinais

• Sinais do tipo wire representam fios ou barramentos (vários bits) – servem para transportar um valor lógico desde uma origem que o produz – um identificador não declarado é considerado um wire de 1 bit

wire en_clock, sel_reg; // fios simples (um bit) wire [15:0] opr_a, opr_b; // dois barramentos de 16 bits

• Sinais do tipo reg representam “registos” (um ou mais bits) – seguram valores lógicos

reg clock, reset; // registos de 1 bit reg [7:0] Ra, Rb; // registos de 8 bits

reg [15:0] regfile[0:31]; // vector de 32 registos com 16 bits cada

• Campos de vectores de bits

Rb; // todo o registo Rb de 8 bits

opr_a[15:8]; // os 8 bits mais significativos de opr_a

Rb[3]; // o bit 3 do registo Rb

regfile[6]; // o elemento no endereço 6 do vector regfile;

Parametrização

• Aumentar a legibilidade

module my_multiply(...); parameter size=16, delay=5; ...

endmodule

my_multiply #(8,2) mult1(...);

valores por omissão valores atribuídos

// Codificaçao de estados: parameter INIT = 2’b00; parameter S0=2’b01, S1=2’b11; ...

if (state==INIT) //if (state==2’b00) nextstate=S1;

...

• Tornar a descrição

genérica

module FCP(a, b, out); // Largura do operando parameter WIDTH = 32; input [WIDTH-1:0] a, b; ...

(20)

Tempos de propagação

• Não suportados em modelos sintetizáveis

• Na instanciação de primitivas são especificados com o operador #

and #3 and_1(o1, x1, x2, x3; // tp = 3 unidades de tempo and #(3,5) and_2(out2, a, b); // tplh=3, tphl=5

bufif1 #(3,2,5) buf_1(out, in, en) // tplh=3, tphl=2, tpHiZ=5

• Para cadatempo podem ser especificados valores min, typ e max

and #(3:4:5) myand(out2, a, b); // tpmin=3, tptyp=4, tpmax=5 bufif1 #(1:2:3,2:3:4,3:4:6) buf_1(out, in, en) //atrasos min:typ:max

• O valor da unidade de tempo é definido pela directiva `timescale

`timescale 1ns/100ps // uma unidade=1ns; precisão de simulação=0.1ns

Verilog system tasks

Algumas funções internas do simulador (system tasks)

– $monitor()

• imprime um registo de texto formatado quando um sinal muda de estado • a sintaxe é semelhante à função printf() da linguagem C

• num projecto só pode existir activo um monitor de sinais

– $time

• devolve o tempo actual do simulador (um inteiro)

– $display()

• quando invocado imprime um registo de texto formatado

– $stop

• interrompe a simulação mas pode ser retomada (breakpoint)

– $finish

(21)

Modelos comportamentais

• Um modelo comportamental é formado por:

– um ou mais processos que operam concorrentemente • assign: blocos combinacionais

• always: blocos combinacionais, sequenciais ou síncronos • Modelo de um full-adder (combinacional)

module full_adder_comp(a, b, cin, s, cout); input a, b, cin; output s, cout; reg cout; assign s = a ^ b ^ cin; always @( a or b or cin ) begin

cout = (a & b) | (a & cin) | (b & cin);

end endmodule modela blocos combinacionais sempre que ... o sinal s está “ligado” à expressão operadores lógicos

Modelos comportamentais

Modelo comportamental do somador de 4 bits

module four_bit_adder_c(a, b, cin, s, cout); input [3:0] a, b;

input cin; output [3:0] s; output cout; reg cout, s;

reg [5:0] ta, tb, ts; // “registos” temps. always @( a or b or cin or ta or tb or ts ) begin ta = { 1’b0, a, 1’b1 }; tb = { 1’b0, b, cin }; ts = ta + tb; cout = ts[5]; s = ts[4:1]; end sempre que... concatenação de bits somador extração de resultados

(22)

Modelos comportamentais

• task

– equivalente a um procedimento – pode chamar-se a si próprio

usando os mesmos registos locais

• function

– equivalente a uma função – retorna um valor

– não pode conter instruções com temporizações ou eventos

Estruturação em “subrotinas”

multiply(a,b,acc); ... task multiply input [15:0] a, b; output [31:0] prod; begin ... end endtask if (testDF(d1,d2)==2’b00) ... function [1:0] testDF; input [1:0] Duab, Dvab;

begin ... testDF=2’b01; end endfunction

Circuitos síncronos

O elemento mais simples: um flip-flop tipo D

module my_DFF(clk, d, q); input clk, d; output q; reg q; always @( negedge clk ) begin q <= d; end endmodule modela um bloco síncrono com clk sempre que clk q “segura” um valor lógico

(23)

Modelação de circuitos síncronos

Ex: acumulador de 8 bits

module acc(clk, reset, a, reg_sum); input clk, reset; input [7:0] a; output [7:0] reg_sum; reg [7:0] reg_sum; always @( negedge clk ) if ( reset ) reg_sum <= 8’d0; else reg_sum <= a + reg_sum; endmodule processo síncrono com clk sempre que clk reg_sum “segura” um valor lógico reg_sum a D Q clk 0 reset circuito inferido reset síncrono com clk

Contador up/down

module updown_counter(clk, reset, enable, down, dout, end_count); input clk, reset, enable, down;

output [3:0] dout; reg [3:0] dout; output end_count;

assign end_count = enable & (down ? (dout==0) : (dout==15) ); always @( posedge clk or posedge reset)

begin if ( reset ) dout <= 0 else begin if ( enable ) if ( down ) dout <= dout – 1; else dout <= dout + 1; end end processo síncrono com o flanco ascendente de clk e reset (assíncrono) processo combinacional a avaliação do sinal de reset tem de ocorrer

no início do bloco begin...end

(24)

Testbench para o contador

up/down

`timescale 1ns/100ps

module updown_counter_testbench; reg clk, reset, enable, down; wire [3:0] dout;

wire end_count;

updown_counter count_1(clk, reset, enable, down, dout, end_count);

initial begin

down = 0; reset = 0; enable = 1; #2 reset = 1; // apply reset #6 reset = 0; // release reset #300 // count up 300ns enable = 0; #40 // disable counter down = 1; #100 // count down

enable = 1; #300 // enable counter, wait 300ns

$stop; // stop simulation end

initial clk = 1’b0;

always #5 clk = ~clk; // 10ns clock period endmodule estímulos instância do contador sinal de relógio

Projecto de um contador de 4 bits

Modularidade e hierarquia de counter

– estruturado em 3 módulos: c16, Dff e clockgen – clockgen produz o sinal de relógio

– contador c16 usa instâncias do módulo Dff (flip-flops tipo D) – hierarquia do modelo:

clockgen c16

Dff Dff Dff Dff

(25)

Projecto de um contador de 4 bits

Modelo do contador c16

module c16(value, clock, fifteen, ten); input clock;

output [3:0] value; output fifteen, ten;

Dff D1(value[0], clock, ~value[0]),

D2(value[1], clock, value[1] ^ value[0]), D3(value[2], clock, value[2] ^ &value[1:0]), D4(value[3], clock, value[3] ^ &value[2:0]); assign fifteen = &value;

assign ten = value[3] & ~value[2] & value[1] & ~value[0]; endmodule

vector de bits

operadores lógicos saída ten vale 1 quando value = 1010

saídas de 1 bit

Projecto de um contador de 4 bits

Modelo (comportamental) do flip-flop tipo D (Dff)

module Dff(q, clock, d); input clock, d; output q; reg q; initial q = 0; always @ (negedge clock) #10 q = d; endmodule

q é reg porque “segura” um valor

no início da simulação (t=0) sempre que clock

(26)

Projecto de um contador de 4 bits

Gerador de relógio (clockgen)

module clockgen(clock); output clock; reg clock; initial #5 clock = 1; always #50 clock = ~clock; endmodule para sempre... sinal clock gerado:

t=05 50 50

unidades de tempo reais: ‘timescale 1ns/100ps

unidade de atraso arredondamento dos cálculos

Projecto de um contador de 4 bits

O circuito completo (módulo counter)

module counter; wire [3:0] count;

wire clock, ten, fifteen;

c16 contador( count, clock, fifteen, ten); clockgen clock( clock );

initial

$monitor($time, “ Clk=%b, Count=%d, is_10=%b, is_15=%b”, clock, count, ten, fifteen);

(27)

Testbench

circuito a fabricar geração de estímulos análise de respostas modelo sintetizável

(vai ser um circuito digital)

modelo não sintetizável (testbench) clock reset memórias A/D e D/A interfaces ficheiros ... simula o comportamento de dispositivos externos

analisa respostas para verificar a correcção do modelo

registos de texto

waveforms

ficheiros ...

Atribuições blocking/nonblocking

• Atribuições procedimentais (blocking) – avaliadas em sequência

• Atribuições non-blocking – avaliadas em paralelo

begin

a1<=in0+in1-acc; y1<=a1+b1; z1<=y1+a1;

end

Admitindo que in0=4,in1=4,acc=1 a1=4, b1=4, y1=8 a1 = 4+4-1 = 7; y1 = 7+4 = 11; z1 = 11+7 = 18; a1 = 7; y1 = 4+4 = 8; z1 = 8+4 = 12; begin a1=in0+in1-acc; y1=a1+b1; z1=y1+a1; end

(28)

Atribuições blocking/nonblocking

module shiftReg(clk, rst, E, A);

input clk, rst, E; output A; reg A, B, C, D;

always @(posedge clk or posedge rst) begin

if (rst) begin A=0; B=0; C=0; D=0; end else begin A=B; B=C; C=D; D=E; end end endmodule D=E; C=D; B=C; A=B; A<=B; // D<=E; B<=C; // C<=D; C<=D; // B<=C; D<=E; // A<=B;

Atribuições blocking/nonblocking

Quando usar a=b ou a<=b ?

– em processos combinacionais podem-se usar os dois tipos – em processos síncronos deve-se usar apenas non-blocking

• evita a ocorrência de race conditions que podem “encravar” o simulador

always @(posedge clk) begin ... if ( dataready ) rdy = 1; ... end always @(posedge clk) begin ... if ( rdy ) begin reg = datain; ack = 1; end end

(29)

Blocos sequenciais e paralelos

begin // sequencial x = k; #10 y = a + b; #5 z = y * x; end begin x = k; fork #10 y = a + b; #5 z = y * x; join end avaliadas em paralelo inicia bloco paralelo

termina bloco paralelo

x y z 10 5 x y z 10 5

Latches em blocos combinacionais

Num modelo de um circuito combinacional

– as saídas devem ter um valor atribuído para todas as condições das entradas

– se esta condição não for satisfeita são criadas latches transparentes – a ocorrência de latches num bloco que se pretendia combinacional

é geralmente fatal

always @(a or b or sel) begin if ( sel ) y = a; else y = b; end

always @(a or b or sel) begin

if ( sel )

y = a;

end

(30)

AJA, FEUP PSDI - Linguagens de descrição de hardware - Verilog 58 (z e x são don’t care)

Construções condicionais

• if (condition) statement1 else statement2 • case (expression) expr1: statement1; expr2: statement2; default: statement3; endcase; • (expression)?(true):(false)

if (a[2:0]==3’b010 && cy)

... casez casex (z é don’t care) case (ir[7:4]) 4’b0001: ... 4’b0010: ... default: ... endcase casex (ir[7:4]) 4’bxx01: ... 4’bxx10: ... default: ... endcase acc=(ir[7:0]==4’b0011) ? 0 : 255;

if (done && init)

{out, play}=2’b011; else if (ready) begin out=2’b10; play=1; end else {out, play}=3’b110;

Ciclos

• for(start; end_expr; update) statement;

• forever statement;

for(i=0; i<8; i=i+1)

x[i] = x[i+1]; • repeat(fixed_loop_count) statement; repeat(10) begin a[i]=a[i+1]; i=i+1; end;

forever #10 clock = ~clock; while(i<8) begin ... i=i+1; end • while(condition) statement;

(31)

Modelação de máquinas de estados

FSM (Finite State Machine)

– sequência determinada de estados, sincronizada com relógio – estrutura geral (saídas Moore) saída próximo estado registo de estado entradas saídas Mealy reset (assíncrono) reset (síncrono) clock saídas Moore saída estado actual próximo estado

Modelação de máquinas de estados

Codificação de estados (feita manualmente)

– atribuição de padrões de bits a cada estado – o tipo de codificação influencia

• dimensão do registo de estado

• complexidade dos circuitos lógicos combinacionais – codificações mais usadas

• sequencial – 0000 0001 0010 0011 0100 … 1101 1110 1111 • código Gray – 0000 0001 0011 0010 0110 … 1011 1001 1000 • código Johnson – 00000000 00000001 00000011 00000111 00001111 … 11100000 11000000 • one-hot – 0000000000000001 0000000000000010 0000000000000100 ...

(32)

Modelação de máquinas de estados

• Mealy

– as saídas dependem do estado corrente e das entradas – o valor das saídas é associado às transições entre estados

• Moore

– as saídas dependem apenas do estado corrente – o valor das saídas é associado aos estados

A B C i1/s1 i2/s2 D E F s3 s3 s4 i1 i3 condição de transição de estado i3 i4 valores das saídas

Máquinas de estados: especificação

• Tabela de transição de estados

• Diagrama

de transição de estados

00 01 10 0X/1 0 1X/0 1 X1/0 X0/1 XX/1 S0 S1 S2 i1/Yme i1/Yme Ymo i2/Yme Yme i2/Yme

entradas estado próximo saídas i1 i2 corrente estado Yme Ymo 0 X 00 (S0) 00 (S0) 1 0 1 X 00 (S0) 01 (S1) 0 0 X 1 01 (S1) 00 (S0) 0 1 X 0 01 (S1) 10 (S2) 1 1 X X 10 (S2) 00 (S0) 1 1 saídas Mealy i1 i2/Yme Ymo

(33)

Modelação de máquinas de estados

em Verilog

Modelo incorrecto!

module FSM_mal(clock, i1, i2, Yme, Ymo); input clock, i1, i2;

output Yme, Ymo; reg Yme, Ymo; reg [1:0] state; always @(posedge clock)

case (state) 2’b00: begin Ymo<=0; if (i1) begin state<=2’b01; Yme<=0; end else Yme<=1; end 2’b01: begin Ymo<=1; if (i2) begin state<=2’b00; Yme<=0; end else begin state<=2’b10; Yme<=1; end end 2’b10: begin

Ymo<=1; state<=2’b00; Yme<=1; end endmodule 00 01 10 0X/1 0 1X/0 1 1 X1/0 _X0/1 XX/1 i1 i2/Yme Ymo

Onde estão os erros ?

• falta de reset (síncrono e/ou assíncrono) • todas as saídas são registadas

• Yme não é saída de Mealy • não é definido o estado inicial • falta o estado2’b11

Modelo correcto

00 01 10 0X/1 0 1X/0 1 1 X1/0 _X0/1 XX/1 i1 i2/Yme Ymo

always @(state or i1 or i2) begin case (state) 2’b00: begin nextstate=2’b00; Ymo=0; if (i1) begin nextstate=2’b01; Yme=0; end else Yme=1; end 2’b01: begin Ymo=1; if (i2) begin nextstate=2’b00; Yme=0; end else begin nextstate=2’b10; Yme=1; end end 2’b10: begin

Ymo=1; nextstate=2’b00; Yme=1; end

default: begin

Ymo=0; nextstate=2’b00; Yme=1; end

module FSM_bem(reset, clock, i1, i2, Yme, Ymo); input reset, clock, i1, i2; output Yme, Ymo;

reg Yme, Ymo;

reg [1:0] state, nextstate; always @(posedge clock)

if (reset) state<=2’b00;

Modelação de máquinas de estados

em Verilog

(34)

Alternativa 1: separação da lógica do próximo

estado das saídas

always @(state or i1 or i2) begin case (state) 2’b00: if (i1) nextstate=2’b01; else nextstate=2’b00; 2’b01: begin if (i2) nextstate=2’b00; else nextstate=2’b10; end 2’b10: nextstate=2’b00; default: nextstate=2’b00; end endmodule

always @(state or i1 or i2) begin case (state) 2’b00: begin Ymo=0; if (i1) Yme=0; else Yme=1; end 2’b01: begin Ymo=1; if (i2) Yme=0; else Yme=1; end 2’b10: begin Ymo=1; Yme=1; end default: begin Ymo=0; Yme=1; end end endmodule

Modelação de máquinas de estados

em Verilog

… (registo de estado)

Alternativa 2: combinando estado corrente e próximo estado

always @(posedge clock or negedge reset) begin if (!reset) state <= 2’b00; else case (state) 2’b00: if (i1) state<=2’b01; else state<=2’b00; 2’b01: begin if (i2) state<=2’b00; else state<=2’b10; end 2’b10: begin state<=2’b00; end default: begin state<=2’b00; end end endmodule

Modelação de máquinas de estados

em Verilog

(35)

AJA, FEUP PSDI - Linguagens de descrição de hardware - Verilog 68 Alternativa 3: combinando estado corrente com próximo estado e

modelando Ymo como saída síncrona

always @(posedge clock or negedge reset) begin if (!reset) begin Ymo<=0; state <= 2’b00; end else case (state) 2’b00: if (i1) begin Ymo<=1; state<=2’b01; end else begin Ymo<=0; state<=2’b00; end ...