Baixado 39 vezes
![Verilog - introdução
• Modelo do contador c16
module c16(value, clock, fifteen, ten);
input clock; vector de bits
output [3:0] value;
output fifteen, ten; saídas de 1 bit
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; operadores
assign ten = value[3] & ~value[2] & value[1] & ~value[0];
endmodule
saída ten vale 1 quando value = 1010
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 31
José Carlos Alves
Verilog - introdução
• Modelo (comportamental) do Dff
module Dff(q, clock, d);
input clock, d;
output q;
reg q; q é reg porque “segura” um valor
initial
q = 0;
no início da simulação (t=0)
always
@ (negedge clock)
#10 q = d; sempre que clock
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 32
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-16-320.jpg)
![Verilog - introdução
• Gerador de relógio (clockgen)
module clockgen(clock);
output clock;
reg clock;
initial
#5 clock = 1; para sempre...
always sinal clock gerado:
#50 clock = ~clock;
endmodule
5 50 50
t=0
arredondamento
dos cálculos
unidades de tempo reais: ‘timescale 1ns/100ps
unidade de atraso
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 33
José Carlos Alves
Verilog - introdução
• 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);
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 34
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-17-320.jpg)
![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:
– portos 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]
– portos 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
• valores lógicos: 1, 0, x (desconhecido) e z (estado de alta impedância)
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 37
José Carlos Alves
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;
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 38
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-19-320.jpg)
![Verilog – modelos estruturais
• um somador de 4 bits
– usando instâncias do full-adder anterior
a e b são
entradas de
4 bits module four_bit_adder(a, b, cin, s, cout);
input [3:0] a, b;
s é uma input cin;
saída de output [3:0] s;
4 bits output cout; sinais ligados
wire [2:0] cy; por posição
cy é um
bus de 3 bits sinais ligados
full_adder fa_0( a[0], b[0], cin, s[0], cy[0] ),
por nome
fa_1( a[1], b[1], cy[0], s[1], cy[1] ),
nome do
fa_2( a[2], b[2], cy[1], s[2], cy[2] ),
componente
fa_3(.cin(cy[2]),.a(a[3]),.b(b[3]),.s(s[3]),.co(cout));
nomes das
instâncias endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 41
José Carlos Alves
verificação funcional
• um testbench instancia o módulo four_bit_adder.
`timescale 1ns/100ps módulo sem interface (testbench)
module four_bit_adder_testbench;
reg [3:0] a, b;
reg cin; registos (seguram valores)
wire [3:0] s;
wire cout; fios (propagam valores)
o circuito a testar
four_bit_adder adder4(a, b, cin, s, cout);
monitor
initial quando o simulador inicia... de sinais
begin
$monitor($time, “ ci=%b, a=%d, b=%d, s=%d, co=%b”, cin, a, b, s, cout);
estímulos cin=0; a=2; b=4; #30
de b=12; #30 espera 30 unidades de tempo (30ns)
simulação cin=1; #30
a=4'b1110; b=4'b0110; #30
$stop; controlo do simulador (pára)
end
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 42
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-21-320.jpg)
![verificação funcional
• Verificação exaustiva do somador de 4 bits
• e se fosse de 32 bits ? (com 1ns por vector seriam necessários 1170 anos!)
module four_bit_adder_testbench;
reg [3:0] a, b; reg cin;
wire [3:0] s; wire cout;
four_bit_adder adder4(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
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 45
José Carlos Alves
constantes
• por omissão: decimal, 32 bits em complemento para dois
– são truncadas se forem atribuídas a sinais com menos bits (a partir do LSB):
reg [3:0] a;
...
initial
begin
a = 28; // 28=11100 -> a fica com 1100=1210
...
end
• pode-se (deve-se) definir o número de bits e a base de
representação:
5’d10; // a constante decimal 10 com 5 bits
10’b1010_0011_11; // constante com 10 bits, em binário
16’h1E_C6; // 16 bits em em hexadecimal
valor (pode-se usar o separador “_” entre dígitos)
base de representação
nº de bits
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 46
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-23-320.jpg)
![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.
sempre que...
always @( a or b or cin or ta or tb or ts )
begin concatenação de bits
ta = { 1’b0, a, 1’b1 };
tb = { 1’b0, b, cin }; somador
ts = ta + tb;
cout = ts[5]; extrair os resultados
s = ts[4:1];
end
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 49
José Carlos Alves
operadores (semelhantes aos da linguagem C)
operador #opr observações
aritméticos + - * / % 2 operandos são estendidos com zeros
lógicos ! negação lógica 1 zero é falso, não-zero é verdadeiro
&& E lógico 2 retorna 1-verdadeiro ou 0-falso
|| OU lógico 2
relacionais > < >= <= 2 operandos considerados unsigned
igualdade == != 2 comparam apenas zeros e uns
=== !== 2 comparam também os valores z e x
bitwise ~ & | ^ 2 operandos são estendidos com zeros
shift >> << 2 desloca bits e preenche sempre com zeros
concatenação { } N {3’b101,1’b0,3’b111}=7’b1010111
replicação {{ }} N {N{A}} replica N vezes o valor A
condicional ? : 3 igual à expressão condicional de C
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 50
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-25-320.jpg)
![modelação de blocos combinacionais
• assign sinal = expressao;
– Liga permanentemente sinal ao resultado da expressao:
assign #10 opa = { a<<7, ( IR[7:4] & 4’b1010 ? (a+b) : (a-b) ) };
atraso de transporte (não pode ser usado em modelos sintetizáveis)
• always @(a or b or c or ...) begin ... end
– sempre que um sinal da lista muda de estado avalia o bloco:
always @(a or IR or b)
lista de sensibilidades
begin
if ( IR[7:4] & 4’b1010 )
a
opa = { a<<7, (a+b) };
else IR opa
opa = { a<<7, (a-b) }; b
end
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 51
José Carlos Alves
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 essa condição não for satisfeita são criadas latches transparentes
– a ocorrência de latches num bloco que se pretendia combinacional
é geralmente FATAL (a ver mais tarde)
always @(a or b or sel)
begin always @(a or b or sel)
if ( sel ) begin
y = a; if ( sel )
else y = a;
y = b; end
end
uma latch transparente
um multiplexer 2÷1
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 52
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-26-320.jpg)
![construções condicionais
if (a[2:0]==3’b010 && cy)
if (condition) ...
statement1
else
statement2 if (a[2:0]===3’b01z && cy)
...
case (expression) case (ir[7:4])
expr1: statement1; 4’b0001: ...
expr2: statement2; 4’b0010: ...
default: statement3; default: ...
endcase; endcase
casez casex (ir[7:4])
(z é don’t care) 4’bxx01: ...
4’bxx10: ...
casex default: ...
(z e x são don’t care) endcase
(expression)?(true):(false) acc=(ir[7:0]==4’b0011) ? 0 : 255;
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 53
José Carlos Alves
ciclos
(utilização restrita em modelos sintetizáveis)
for(start;end_expr;update)
for(i=0;i<8;i=i+1)
statement; x[i] = x[i+1]
while(condition) while(i<8)
statement; begin
...
end
repeat(10)
repeat(fixed_loop_count) begin
statement; a[i]=a[i+1];
i=i+1;
end;
forever statement; forever #10 clock = ~clock;
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 54
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-27-320.jpg)
![modelação de circuitos síncronos
• 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;
reg_sum “segura” um
valor lógico
always @( negedge clk )
if ( reset )
processo
reg_sum <= 8’d0;
síncrono com clk sempre que clk
else
reg_sum <= a + reg_sum;
endmodule
reset
D Q reg_sum
a
0
clk
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 55
José Carlos Alves
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; processo combinacional
output end_count;
assign end_count = enable & (down ? (dout==0) : (dout==15) );
always @( posedge clk or posedge reset)
begin
if ( reset )
dout <= 0
else processo síncrono
begin com o flanco ascendente
if ( enable ) de clk e reset assíncrono
if ( down )
dout <= dout – 1;
a avaliação do sinal de reset
else
tem de ocorrer no início do
dout <= dout + 1;
bloco begin...end
end
end
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 56
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-28-320.jpg)
![testbench para o contador up/down
`timescale 1ns/100ps
module updown_counter_testbench;
reg clk, reset, enable, down;
wire [3:0] dout; instância do contador
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 estímulos
#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; sinal de
always #5 clk = ~clk; // 10ns clock period relógio
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 57
José Carlos Alves
atribuições blocking/nonblocking
• Atribuições procedimentais – avaliadas em sequência
Admitindo que in0=4,in1=4,acc=1
begin a1=4, b1=4, y1=8
a1=in0+in1-acc;
y1=a1+b1; a1 = 4+4-1 = 7;
z1=y1+a1; y1 = 7+4 = 11;
end z1 = 11+7 = 18;
• Atribuições non-blocking – avaliadas em paralelo
begin
a1<=in0+in1-acc; a1 = 7;
y1<=a1+b1; y1 = 4+4 = 8;
z1<=y1+a1; z1 = 8+4 = 12;
end
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 58
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-29-320.jpg)
![Máquinas de estados - especificação
• Tabela de transição de estados
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
• Diagrama de transição de estados
Ymo 0 1 Ymo
1X/0 i1/Yme
00 01 i1/Yme S1
S0
0X/1
X1/0 i2/Yme
X0/1 i2/Yme
XX/1
Yme
i1 i2/Yme 10 saídas Mealy S2
1 saídas Moore Ymo
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 65
José Carlos Alves
Máquinas de estados - modelação em Verilog
module FSM_mal(clock, i1, i2, Yme, Ymo);
• Modelo incorrecto input clock, i1, i2;
output Yme, Ymo;
reg Yme, Ymo;
reg [1:0] state;
always @(posedge clock)
Ymo 0 1 case (state)
1X/0 2’b00: begin
00 01
Ymo<=0;
0X/1 if (i1)
X1/0
X0/1 begin
XX/1
state<=2’b01; Yme<=0;
end
i1 i2/Yme 10 else
1 Yme<=1;
end
2’b01: begin
Ymo<=1;
if (i2)
begin
state<=2’b00; Yme<=0;
end
else
begin
state<=2’b10; Yme<=1;
Onde estão os erros ? end
end
2’b10: begin
Ymo<=1; state<=2’b00; Yme<=1;
end
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 66
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-33-320.jpg)
![Máquinas de estados - modelação em Verilog
module FSM_mal(clock, i1, i2, Yme, Ymo);
• Modelo incorrecto input clock, i1, i2;
output Yme, Ymo;
reg Yme, Ymo;
reg [1:0] state;
always @(posedge clock)
case (state)
Ymo 0 1 2’b00: begin
1X/0 Ymo<=0;
00 01 if (i1)
0X/1 begin
X1/0 state<=2’b01; Yme<=0;
X0/1
end
XX/1 else
i1 i2/Yme 10 Yme<=1;
1 end
2’b01: begin
Ymo<=1;
if (i2)
begin
state<=2’b00; Yme<=0;
• falta de reset (síncrono e/ou assíncrono) end
else
• todas as saídas são registadas begin
state<=2’b10; Yme<=1;
• Yme não é saída Mealy end
end
• não é definido o estado inicial 2’b10: begin
• falta o estado 2’b11 Ymo<=1; state<=2’b00; Yme<=1;
end
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 67
José Carlos Alves
Máquinas de estados - modelação em Verilog
always @(state or i1 or i2)
• Modelo correcto begin
case (state)
2’b00: begin
nextstate=2’b00;
Ymo 0 1 Ymo=0;
1X/0 if (i1)
00 01
begin
0X/1 nextstate=2’b01; Yme=0;
X1/0
X0/1 end
else
XX/1 Yme=1;
i1 i2/Yme 10 end
1 2’b01: begin
Lógica de geração Ymo=1;
if (i2)
Memória de estado do próximo estado begin
e das saídas nextstate=2’b00; Yme=0;
end
else
module FSM_bem(reset, clock, begin
i1, i2, Yme, Ymo); nextstate=2’b10; Yme=1;
input reset, clock, i1, i2; end
output Yme, Ymo; end
reg Yme, Ymo; 2’b10: begin
reg [1:0] state, nextstate; Ymo=1; nextstate=2’b00; Yme=1;
end
always @(posedge clock) default: begin
if (reset) Ymo=0; nextstate=2’b00; Yme=1;
state<=2’b00; end
else end
state<=nextstate; endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 68
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-34-320.jpg)
![Construção de modelos sintetizáveis
– inferência de buffers de 3-estados
• atribuindo z a um sinal (do tipo reg)
module three_state(in, out, en);
input in, en;
output out;
reg out;
always @( in or en)
if (en)
out = in;
else assign out = en ? in : 1’bz;
out = 1’bz;
endmodule
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 79
José Carlos Alves
Construção de modelos sintetizáveis
– ciclos
• for(...): só são suportadas 4 formas:
– crescente ou decrescente de passo constante (...;index=index±step)
– condição de terminação com <, >, <= ou >=
always @( a or b or carry )
for(i=0;i<=31;i=i+1)
begin
s[i] = a[i]^b[i]^carry;
carry = a[i]&b[i] | a[i]&carry | b[i]&carry;
end
• while (...): cria um ciclo combinacional;
deve ser quebrado com @(posedge clock)
always @( posedge clock )
while (x<y)
begin
@(posedge clock);
x=x+z;
end
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 80
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-40-320.jpg)
![Sincronização de estímulos
initial // apply reset
begin // for 2 clocks
rst <= 1’b0; clk
clk <= 1’b0;
repeat (2)
#50 clk <= ~clk; rst
rst <= 1’b1;
repeat (4)
#50 clk <= ~clk; não ocorre competição
rst <= 1’b0;
reset muda ao mesmo tempo que clk;
forever #50 clk <= ~clk; quando clk troca, rst ainda tem o estado
end anterior (atribuições non-blocking)
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 109
José Carlos Alves
Entrada de dados de ficheiro
• leitura de dados de um ficheiro de texto para um vector
mem é um vector de registos, por exemplo: reg [15:0] mem[0:127]
filename é o nome do ficheiro de texto que contém os dados
os dados são em ASCII, representando números em binário ou hexadecimal
podem ser incluídos comentários; posições não lidas ficam com ‘xxxx’
$readmemb( “filename”, mem, start_index, end_index); // binário
//ficheiro de dados em binario
@00 // endereço 0x00 (zero, em hexadecimal)
0000_0000_0000_0001 // dado, o caracter ‘_’ é um separador
0000_0000_0000_1000
@10 // os dados seguintes sao colocados a partir do endereço 0x10
0000000000001011
$readmemh( “filename”, mem, start_index, end_index); // hex
//ficheiro de dados em hexadecimal
@00 // endereço 0x00 (zero, em hexadecimal)
00_01 // dado, o caracter ‘_’ é um separador
0AFE
@10 // os dados seguintes sao colocados a partir do endereço 0x10
FF_0B
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 110
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-55-320.jpg)
![Saída de dados para ficheiros de texto
• $fopen, $fclose, $fmonitor, $fwrite, $fdisplay
integer HI, HQ; // File handlers
initial // open output files
begin
HI = $fopen(“dout_I.dat”);
HQ = $fopen(“dout_Q.dat”);
// simulate ... close files
$fclose(HI); $fclose(HQ);
end
initial
$fmonitor(fh,...); // $monitor para ficheiro
always @(posedge clock)
begin
$fdisplay( HI, “%d”, HI); // inclui newline
$fwrite( HQ, “%dn”, HQ); // nao inclui newline
end
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 111
José Carlos Alves
Monitorização de valores
• nomes hierárquicos – operador . (ponto)
task dump_regfile; // dump CPU registers
integer i;
begin
for(i=0;i<8;i=i+1)
$display(“R%d=%d (%h)”, i, mycpu.regfile_1.regs[i],
mycpu.regfile_1.regs[i] )
end
initial
begin
// apply reset and check initial state
$display(“Ctrl unit initial state: %b”, mycpu.ctrl_1.state);
end
mycpu
sinal da instância ctrl_1 dentro de mycpu ctrl_1
reg [4:0] state;
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 112
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-56-320.jpg)
![Geração de números aleatórios
• geração de estímulos aleatórios (valor ou tempo)
$random(seed); // inicia o gerador de números aleatórios
x = $random; // retorna um inteiro aleatório (32 bits)
x = $random / 32’h0fff_ffff; // inteiro entre [0..15]
• especificação de atrasos não constantes: #( expressão )
integer x;
reg [15:0] y;
reg [7:0] cmd;
x = $random / 32’h00ff_ffff; y = $random / 32’h0fff_fffa;
cmd = $random / 32’h3fff_ffff;
for(i=0; i<MAXLOOP; i=i+1)
begin
#(x) apply_initcommand;
#(x*y/3) send_command( cmd, data);
end
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 113
José Carlos Alves
tasks
• Sub-rotinas em Verilog
– Interesse particular para a construção de testbenches
– Podem conter atrasos, chamadas a outras tasks
task writecommand;
input [15:0] data; // data to write
input [1:0] address; // address of output port
begin
din = {4'b0010, 2’b00, address}; // compose and write
command
load = 1; #10 load = 0; #10 // ld for 1 clock
din = data[15:8]; // send MS byte
load = 1; #10 load = 0; #20 // ld for 2 clocks
din = data[7:0]; // send LS byte
load = 1; #10 load = 0; #30 load = 0;
end initial
endtask begin
…
writecommand(16'h39A6, 2'b00 );
FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 114
José Carlos Alves](https://image.slidesharecdn.com/vhdlmux-111020143251-phpapp02/85/Vhdl-mux-57-320.jpg)
Vhdl mux
- 1. Projecto de SistemasDigitais (EEC0055) Mestrado Integrado em Engenharia Electrotécnica e de Computadores 4º ano, 2º semestre António José Araújo (aja@fe.up.pt) Hélio Sousa Mendonça (hsm@fe.up.pt) http://www.fe.up.pt/~aja/PSDI_200607-2S FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 1 José Carlos Alves Projecto de Sistemas Digitais • Tecnologias digitais cada vez mais importantes – vastas áreas de aplicação – evolução tecnológica exponencial (lei de Moore) • tamanho, consumo, rapidez – custo continua a descer (um PC custa 1000€!) • Um sistema (electrónico) digital deve ser… (numa perspectiva industrial) – bom: satisfazer a funcionalidade com fidelidade e fiabilidade – barato: custo mais baixo possível, sem comprometer a qualidade • Projectar um SD – “if it wasn’t hard they wouldn’t call it hardware”, J.F. Wakerly – ferramentas computacionais ajudam “the little gray cells” mas não substituem FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 2 José Carlos Alves
- 2. Fluxo de projecto(típico) um controlador de intensidade luminoasde para ligar sempre que anguem casa eou sai da luzes do desligar entra se chama bobi e caoreceptor casota tem que tareco gatoa que 1- se -chama paraum tambem calcular luz 2 um cpu always @(posedge clock or posedge reset) 3 - interface de potência begin face proces sador case(state) Ideia inter start: begin if ( enable) ready <= 1; memória else ready <= 0; state <= waitfor; end endcase end sistema (abstracto) validação circuito (RTL – lógico) D Q validação mapeamento D tecnológico Q validação fabrico teste IC /dev/null FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 3 José Carlos Alves Concepção • Ideia – clarificar e estruturar a ideia, definir especificações • um produto é muito mais do que o sistema digital • por vezes um projecto é iniciado com especificações incompletas • Exequibilidade – boas ideias podem não ser praticáveis • custo ou risco elevado • tecnologia não acessível, não dominada ou não adequada • tempo de desenvolvimento demasiado longo • Implementação – Parte do projecto pode ser independente da tecnologia alvo... – ...mas deve ser decidida o mais cedo possível no ciclo de projecto FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 4 José Carlos Alves
- 3. Aspectos tecnológicos • Que tecnologia? – ASIC, FPGA, componentes off-the-shelf? • Particionamento arquitectural – um sistema pode não “caber” num único componente • tamanho, número de terminais, tecnologia de fabrico • divisão da funcionalidade (por exemplo analógico vs. digital) • selecção dos componentes e da tecnologia de montagem funcionalidade rapidez disponibilidade LSI número de pinos interface CPU ASIC encapsulamento fabricante(s) mP memória RAM PCB co-proc COB I/O proc MCM wire-wrap FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 5 José Carlos Alves Tecnologias disponíveis (para implementar sistemas digitais) • ASIC (CMOS) – Centenas de MHz, baixo consumo, custos fixos elevados – Densidades: 250K gates/mm2 (90nm), 320K (65nm) • FPGA – Centenas de MHz, consumo elevado, sem custos fixos – Reconfiguráveis! – 10.000.000 gates (equivalentes…) num único chip • Microcontroladores/microprocessadores – Baixo custo, baixo desempenho, programáveis – Muitas configurações com variados periféricos • Exemplos: os PIC da Microchip, muitos derivados do 8051 • Circuitos discretos – Circuitos “off-the-shelf”, funcões específicas (ASICs) – Circuitos integrados digitais para SSI e MSI (série 74…) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 6 José Carlos Alves
- 4. Justifica-se um ASIC/FPGA? • Alguns dos aspectos a ter em conta – rapidez (MHz, MIPS, MFLOPS) – consumo de energia – tamanho físico – custo (das ferramentas, prototipagem e produção) – complexidade do projecto – Flexibilidade (evoluções futuras?) – fiabilidade – testabilidade – dissipação térmica – compatibilidade electromagnética – resistência mecânica FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 7 José Carlos Alves Ferramentas computacionais • CAD/CAE (Computer Aided Design/Computer Aided Engineering) – fundamentais para projectar em tempo útil circuitos complexos – Muitos problemas são NP-hard • Ferramentas CAD/CAE – trabalham com representações electrónicas de SDs (modelos) – exemplos de ferramentas CAD/CAE • captura esquemática (mais do que desenhar o circuito lógico...) • síntese (layout, lógica, RTL, alto nível) • desenho físico (layout), verificação de regras geométricas • simulação lógica (verificação funcional) • análise temporal • simulação eléctrica • modelação e simulação de faltas • geração de vectores de teste • análise térmica • edição de texto (documentação e não só!) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 8 José Carlos Alves
- 5. Modelos de circuitosdigitais • Representações electrónica de SDs – usadas e transformadas por ferramentas CAD/CAE • Um modelo é uma aproximação! – que pode ser boa e pode ser má… – rigor ⇒ detalhe ⇒ aproximação da tecnologia – a simulação de um modelo nunca é igual ao seu funcionamento real • Modelos (frequentemente) tratados por humanos – modelos estruturais (esquemáticos) • detalham a estrutura do circuito, interligando “componentes” – modelos comportamentais (HDLs, state charts, tabelas, BDDs) • descrevem apenas o comportamento do sistema FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 9 José Carlos Alves Y- chart fluxogramas, estrutural algoritmos transferências processadores, entre registos comportamental memórias expressões booleanas registos, muxs funções de portas lógicas transistores transistores layout de di transistores sp os iti vo ló ão células gi co cç ra RT si st L st módulos, chips ab e m e a sd placas, MCMs i ve ní físico FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 10 José Carlos Alves
- 6. Especificação de umSD • Tradicionalmente… – captura esquemática (estrutural) • interligação de portas lógicas, flip-flops, componentes RTL,… • bibliotecas de componentes específicas de uma tecnologia • anotação do desenho com atributos – nomes, parâmetros, restrições para implementação • captura a estrutura (física) do circuito • transformado de forma optimizada para uma tecnologia alvo – tabelas de verdade, expressões booleanas (comportamental) • conveniente para blocos de lógica combinacional ou FSMs – minimização lógica – codificação de estados • representação textual, tradução automática para um circuito lógico • independente do meio de implementação FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 11 José Carlos Alves Especificação de um SD • Actualmente... – projecto a níveis de abstracção mais elevados • representações comportamentais ao nível RTL e algorítmico • linguagens normalizadas para descrição de hardware – suportadas por ferramentas de síntese automática – combinam modelação estrutural com comportamental – permitem ao projectista abstrair-se da tecnologia alvo – portabilidade e facilidade de manutenção e documentação • redução do ciclo de projecto – permite explorar melhor o espaço de soluções – comparando com a programação de computadores... nível de código máquina layout abstracção assembly portas lógicas crescente C, C++ HDLs FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 12 José Carlos Alves
- 7. Projecto estruturado • Hierarquiae modularidade – conceitos semelhantes aos empregues em programação estruturada – objectivos: • estruturação do projecto • permitir a reutilização de módulos • facilitar a verificação do projecto • simplificar a produção da documentação (geralmente esquecida!) – “quanta” hierarquia ? • critérios principais: – funcionalidade e granularidade (complexidade dos módulos) • uma diferença importante da hierarquia em software: – não significa reduzir a complexidade do hardware – geralmente “desaparece” em algum estágio da implementação FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 13 José Carlos Alves Metodologias de projecto • Abordagens típicas – bottom-up (capture-and-simulation) • hierarquia criada de baixo para cima (lógico ⇒ RTL ⇒ sistema) • ciclo de projecto: manual – desenhar os circuitos mais simples (ou usá-los se existirem) – validar com simulação esses circuitos – usá-los na construção de outros circuitos mais complexos – top-down (describe-and-synthesize) • hierarquia criada de cima para baixo (sistema ⇒ RTL ⇒ lógico) • ciclo de projecto automático – especificar o sistema de forma comportamental – sintetizar e avaliar as soluções resultantes de diferentes restrições – na prática usa-se uma mistura de top-down e bottom-up FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 14 José Carlos Alves
- 8. Validação do projecto • Simulação funcional – verificação funcional da especificação • realizada a diferentes níveis de abstracção (sistema ou RTL) • verificar que é satisfeita a funcionalidade desejada • se não funciona? detecção e depuração de erros (debug) • problemas: – como definir os vectores de simulação ? – como se sabe que o resultado é correcto ? – quão exaustivo é o teste ? – fontes de erro mais comuns • especificações incompletas, ligações erradas ou nomes trocados • uso incorrecto de ferramentas de síntese automática • má organização das várias versões de um projecto • os computadores não erram, os humanos sim… • são humanos que criam as ferramentas de software! FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 15 José Carlos Alves Validação do projecto • Análise temporal – circuitos lógicos introduzem atrasos • a simulação dá resultados correctos considerando os atrasos ? • qual o desempenho ? • o que limita o desempenho ? Como se pode melhorar ? – modelos de atrasos • específicos de uma tecnologia • dependem do circuito em que um componente se insere (fan-out) • quanto mais completo é o modelo, mais complexa é a simulação – tpLH, tpHL, tr, tf (mínimos, típicos e máximos) • interligações também introduzem atrasos – função do comprimento e da forma – só são conhecidos após a implementação ao nível físico FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 16 José Carlos Alves
- 9. Implementação • Síntese lógica – Tradução automática de descrições abstractas (textuais) – Resultado é um netlist que interliga blocos primitivos • Portas lógicas, flip-flops, buffers, RAMs,… • Cada bloco tem uma representação física determinada • Place&Route – Colocação física desses blocos numa área determinada • Minimizar a área, maximizar as relações de proximidade – Construir as interligações definidas no netlist • Satisfazer restrições temporais, minimizar a área – Sinais de relógio devem ser tratados à parte • Ferramentas e processos dedicados para sinais desse tipo FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 17 José Carlos Alves Teste • Teste do sistema fabricado – testar para quê? • minimizar (→ 0%) o número de sistemas defeituosos vendidos • detectar e diagnosticar defeitos de fabrico • melhorar o sistema ou o processo produtivo – como testar ? • construir um modelo de faltas do circuito • criar vectores de simulação que as consigam detectar – saídas diferentes na presença ou ausência da falta – ferramentas para ATPG - Automatic Test Pattern Generation – teste é uma fatia importante do custo de produção • projecto orientado para a testabilidade (DFT - Design for Testability) • auto-teste (BIST - Built-in Self Test) • teste de PCB (boundary scan test, norma IEEE 1149.1) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 18 José Carlos Alves
- 10. Linguagens de descriçãode hardware • Modelação de um circuito (digital) – 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 – a favor do esquemático: “uma figura diz mais do que mil palavras” • um esquema captura 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 – duas perspectivas na construção de um modelo • descrever o seu funcionamento apenas para simulação • construir uma descrição sintetizável ($monitor(…) não é sintetizável!) – um modelo sintetizável deve descrever “bem” o seu funcionamento – subsets das linguagens e regras de modelação dependem das ferramentas FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 19 José Carlos Alves Verilog vs. VHDL - história •VHDL – ‘80: por necessidade de normalização, documentação e portabilidade, e DOD funda projecto para criar linguagem de “programação” para descrever hardware – ‘83: início do desenvolvimento do VHDL (IBM, Texas, Intermetrics) – ‘87: o DOD impõe que todos os SDs fossem descritos em VHDL; standard IEEE 1076; os sistemas electrónicos do F-22 foram um dos primeiros projectos em VHDL – ‘93: VHDL é revisto e adoptado como o standard IEEE 1076 ’93 – ‘96: adopção generalizada por ferramentas EDA; package para ferramentas de síntese (IEEE 1076.3); modelação de bibliotecas para ASIC e FPGA (IEEE 1076.4) •Verilog – ‘81: Gateway Design Automation, Philip Moorby cria GenRad HDL e o simulador HILO – ‘83: Gateway lançou a linguagem Verilog HDL e um simulador de Verilog – ‘85: linguagem e simulador são enriquecidos (Verilog-XL) – ‘87: Synopsys adopta Verilog como formato de entrada para ferramentas de síntese – ‘89/’90: Cadence compra Gateway e separa o simulador da linguagem; a linguagem é libertada para o domínio público; é criado o OVI (Open Verilog International) – ‘93: neste ano, de todos os circuitos submetidos a fundições de silício, 85% foram desenvolvidos e submetidos em Verilog. – ‘95: Verilog é revisto e adoptado como o standard IEEE 1364 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 20 José Carlos Alves
- 11. Verilog e VHDL- 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 hw (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 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 21 José Carlos Alves VHDL-Verilog (comportamental) VHDL Verilog library IEEE; module MUX_2_1(S1,A1,B1,Y1, use IEEE.STD_Logic_1164.all; S2,A2,B2,Y2, entity MUX_2_1 is S3,A3,B3,Y3); port(S1,A1,B1,S2,A2,B2,S3,A3,B3:in std_logic; input S1,A1,B1,S2,A2,B2,S3,A3,B3; Y1,Y2,Y3:out std_logic); output Y1,Y2,Y3; end entity MUX_2_1; reg Y2,Y3; architecture COND_DATA_FLOW of MUX_2_1 is assign Y1=S1?A1:B1; begin Y1 <= A1 when S1=‘1’ else B1; always TWO_2_1_MUXES: @(S2 or A2 or B2 or S3 or A3 or B3) process(S2,A2,B2,S3,A3,B3) begin begin Y2=B2; Y2<=B2; if (S2) if (S2=‘1’) then Y2=A2; Y2<=A2; if (S3) endif; Y3=A3; if (S3=‘1’) then else Y3<=A3; Y3=B3; else end Y3<=B3; endmodule endif; end process TWO_2_1_MUXES end architecture COND_DATA_FLOW; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 22 José Carlos Alves
- 12. VHDL-Verilog (estrutural) VHDL Verilog library IEEE; module HALF_ADDER(a,b,sum,carry); use IEEE.STD_Logic_1164.all; input a,b; output sum,carry; entity HALF_ADDER is port(a,b:in std_logic; xor X1(sum,a,b); sum,carry:out std_logic); and A1(carry,a,b); end entity HALF_ADDER; endmodule 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; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 23 José Carlos Alves Modelação em HDL • Modelo sintetizável vs. modelo 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 é interpretado 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 • definem 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) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 24 José Carlos Alves
- 13. Modelação em HDLs recomendações gerais • Antes de iniciar a construção do modelo – definir a arquitectura e estruturação do 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 reusabilidade – 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 sintetizáveis FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 25 José Carlos Alves Verilog HDL (Hardware Description Language) • Linguagem de descrição de hardware (digital) – Suporta modelação em diferentes níveis de abstracção – criada para modelação e simulação de circuitos digitais – actualmente usada como fonte para ferramentas de síntese – modelos estruturais e modelos comportamentais – não é uma linguagem de programação! • Unidade básica de um modelo em Verilog: – module: um sub-circuito definido por: preset q clear qbar • interface (entradas e saídas) preset q • implementação (modelo do circuito digital) qbar clear FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 26 José Carlos Alves
- 14. Verilog - introdução • Modelo estrutural de uma latch SR com portas NAND: module ffnand(preset,clear,q,qbar); input preset, clear; interface output q, qbar; atraso primitiva nand #1 nand1(q, qbar, preset), implementação nand2(qbar, q, clear); instância endmodule saída entradas • Circuito: preset q clear qbar FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 27 José Carlos Alves Verilog - introdução • Simulação do módulo ffnand escala temporal `timescale 1ns/100ps module top_ffnand; fios wire q, qb; reg pre, clr; registos ffnand ffnand1(pre,clr,q,qb); instância initial begin monitor $monitor($time, de sinais “ preset=%b, clear=%b, q=%b, qbar=%b”, pre, clr, q, qb); espera 10ns #10 pre=0; clr=1; #10 pre=1; #10 clr=0; estímulos #10 clr=1; de simulação #10 $finish; end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 28 José Carlos Alves
- 15. Verilog - introdução • Modelo completo para simulação (testbench) – reunião dos módulos ffnand e top_ffnand • Resultados da simulação – produzidos pela função $monitor(...)(system task) • sempre que algum dos sinais declarados muda de estado – análise das formas de onda de sinais relevantes 0 preset=x clear=x q=x qbar=x valor lógico 10 preset=0 clear=1 q=x qbar=x desconhecido 11 preset=0 clear=1 q=1 qbar=x 12 preset=0 clear=1 q=1 qbar=0 20 preset=1 clear=1 q=1 qbar=0 30 preset=1 clear=0 q=1 qbar=0 31 preset=1 clear=0 q=1 qbar=1 32 preset=1 clear=0 q=0 qbar=1 40 preset=1 clear=1 q=0 qbar=1 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 29 José Carlos Alves Verilog - introdução • Um contador de 4 bits (counter) – estruturação 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: counter c16 clockgen Dff Dff Dff Dff FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 30 José Carlos Alves
- 16. Verilog - introdução • Modelo do contador c16 module c16(value, clock, fifteen, ten); input clock; vector de bits output [3:0] value; output fifteen, ten; saídas de 1 bit 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; operadores assign ten = value[3] & ~value[2] & value[1] & ~value[0]; endmodule saída ten vale 1 quando value = 1010 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 31 José Carlos Alves Verilog - introdução • Modelo (comportamental) do Dff module Dff(q, clock, d); input clock, d; output q; reg q; q é reg porque “segura” um valor initial q = 0; no início da simulação (t=0) always @ (negedge clock) #10 q = d; sempre que clock endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 32 José Carlos Alves
- 17. Verilog - introdução • Gerador de relógio (clockgen) module clockgen(clock); output clock; reg clock; initial #5 clock = 1; para sempre... always sinal clock gerado: #50 clock = ~clock; endmodule 5 50 50 t=0 arredondamento dos cálculos unidades de tempo reais: ‘timescale 1ns/100ps unidade de atraso FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 33 José Carlos Alves Verilog - introdução • 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); endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 34 José Carlos Alves
- 18. Testbench modelo não sintetizável (testbench) clock reset registos de texto memórias geração circuito análise waveforms A/D e D/A de a de ficheiros estímulos respostas ... interfaces fabricar ficheiros ... simula o comportamento de modelo sintetizável analisa respostas para dispositivos externos (vai ser um circuito digital) verificar a correcção do modelo FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 35 José Carlos Alves Verilog • Modelo de um full-adder (estrutural gate-level) `timescale 1ns/100ps module full_adder(a, b, cin, s, co); fios input a, b, cin; interface output s, co; // resultado e carry-out atraso de 3 saída wire t1, t2, t3; unidades de comentário tempo xor #3 xor_1( s, a, b, cin ); instância and #2 and_1( t1, a, b ), and_2( t2, a, cin), implementação primitivas and_3( t3, b, cin); lógicas entradas or #(2,3) or_1( co, t1, t2, t3); endmodule atraso de propagação: tpLH=2 unidades de tempo; tpHL=3 unidades FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 36 José Carlos Alves
- 19. 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: – portos 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] – portos 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 • valores lógicos: 1, 0, x (desconhecido) e z (estado de alta impedância) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 37 José Carlos Alves 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; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 38 José Carlos Alves
- 20. primitivas lógicas • primitivaslógicas implícitas na linguagem Verilog – representam “componentes” que implementam funções lógicas elementares • realizam operações entre sinais de 1 ou mais bits – portas lógicas: and, nand, or, nor, xor, xnor (1º sinal é saída, restantes são entradas) and and_1(o1, x1, x2), and_2(o2, x3, x4, x5, x6, en); – buffers e inversores: buf, not (último sinal é a entrada e os restantes são saídas) not inv_1(nclkout, nclkout1, nclkout2, clkin); buf mybuffer(a, b, c, d, busout); – buffers de 3 estados: bufif1, bufif0 bufif0 tristate_1(out, in, control); – inversores com saída de 3 estados: notif1, notif0 notif0 my_not(not_in, in, control); FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 39 José Carlos Alves 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 cada tempo 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 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 40 José Carlos Alves
- 21. Verilog – modelosestruturais • um somador de 4 bits – usando instâncias do full-adder anterior a e b são entradas de 4 bits module four_bit_adder(a, b, cin, s, cout); input [3:0] a, b; s é uma input cin; saída de output [3:0] s; 4 bits output cout; sinais ligados wire [2:0] cy; por posição cy é um bus de 3 bits sinais ligados full_adder fa_0( a[0], b[0], cin, s[0], cy[0] ), por nome fa_1( a[1], b[1], cy[0], s[1], cy[1] ), nome do fa_2( a[2], b[2], cy[1], s[2], cy[2] ), componente fa_3(.cin(cy[2]),.a(a[3]),.b(b[3]),.s(s[3]),.co(cout)); nomes das instâncias endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 41 José Carlos Alves verificação funcional • um testbench instancia o módulo four_bit_adder. `timescale 1ns/100ps módulo sem interface (testbench) module four_bit_adder_testbench; reg [3:0] a, b; reg cin; registos (seguram valores) wire [3:0] s; wire cout; fios (propagam valores) o circuito a testar four_bit_adder adder4(a, b, cin, s, cout); monitor initial quando o simulador inicia... de sinais begin $monitor($time, “ ci=%b, a=%d, b=%d, s=%d, co=%b”, cin, a, b, s, cout); estímulos cin=0; a=2; b=4; #30 de b=12; #30 espera 30 unidades de tempo (30ns) simulação cin=1; #30 a=4'b1110; b=4'b0110; #30 $stop; controlo do simulador (pára) end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 42 José Carlos Alves
- 22. resultados da simulação (formas de onda) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 43 José Carlos Alves resultados da simulação (texto) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 44 José Carlos Alves
- 23. verificação funcional • Verificaçãoexaustiva do somador de 4 bits • e se fosse de 32 bits ? (com 1ns por vector seriam necessários 1170 anos!) module four_bit_adder_testbench; reg [3:0] a, b; reg cin; wire [3:0] s; wire cout; four_bit_adder adder4(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 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 45 José Carlos Alves constantes • por omissão: decimal, 32 bits em complemento para dois – são truncadas se forem atribuídas a sinais com menos bits (a partir do LSB): reg [3:0] a; ... initial begin a = 28; // 28=11100 -> a fica com 1100=1210 ... end • pode-se (deve-se) definir o número de bits e a base de representação: 5’d10; // a constante decimal 10 com 5 bits 10’b1010_0011_11; // constante com 10 bits, em binário 16’h1E_C6; // 16 bits em em hexadecimal valor (pode-se usar o separador “_” entre dígitos) base de representação nº de bits FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 46 José Carlos Alves
- 24. 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 • termina a execução do simulador (só em alguns simuladores...) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 47 José Carlos Alves 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; modela blocos o sinal s está combinacionais ligado à expressão assign s = a ^ b ^ cin; operadores sempre que... lógicos always @( a or b or cin ) begin cout = (a & b) | (a & cin) | (b & cin); end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 48 José Carlos Alves
- 25. 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. sempre que... always @( a or b or cin or ta or tb or ts ) begin concatenação de bits ta = { 1’b0, a, 1’b1 }; tb = { 1’b0, b, cin }; somador ts = ta + tb; cout = ts[5]; extrair os resultados s = ts[4:1]; end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 49 José Carlos Alves operadores (semelhantes aos da linguagem C) operador #opr observações aritméticos + - * / % 2 operandos são estendidos com zeros lógicos ! negação lógica 1 zero é falso, não-zero é verdadeiro && E lógico 2 retorna 1-verdadeiro ou 0-falso || OU lógico 2 relacionais > < >= <= 2 operandos considerados unsigned igualdade == != 2 comparam apenas zeros e uns === !== 2 comparam também os valores z e x bitwise ~ & | ^ 2 operandos são estendidos com zeros shift >> << 2 desloca bits e preenche sempre com zeros concatenação { } N {3’b101,1’b0,3’b111}=7’b1010111 replicação {{ }} N {N{A}} replica N vezes o valor A condicional ? : 3 igual à expressão condicional de C FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 50 José Carlos Alves
- 26. modelação de blocoscombinacionais • assign sinal = expressao; – Liga permanentemente sinal ao resultado da expressao: assign #10 opa = { a<<7, ( IR[7:4] & 4’b1010 ? (a+b) : (a-b) ) }; atraso de transporte (não pode ser usado em modelos sintetizáveis) • always @(a or b or c or ...) begin ... end – sempre que um sinal da lista muda de estado avalia o bloco: always @(a or IR or b) lista de sensibilidades begin if ( IR[7:4] & 4’b1010 ) a opa = { a<<7, (a+b) }; else IR opa opa = { a<<7, (a-b) }; b end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 51 José Carlos Alves 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 essa condição não for satisfeita são criadas latches transparentes – a ocorrência de latches num bloco que se pretendia combinacional é geralmente FATAL (a ver mais tarde) always @(a or b or sel) begin always @(a or b or sel) if ( sel ) begin y = a; if ( sel ) else y = a; y = b; end end uma latch transparente um multiplexer 2÷1 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 52 José Carlos Alves
- 27. construções condicionais if (a[2:0]==3’b010 && cy) if (condition) ... statement1 else statement2 if (a[2:0]===3’b01z && cy) ... case (expression) case (ir[7:4]) expr1: statement1; 4’b0001: ... expr2: statement2; 4’b0010: ... default: statement3; default: ... endcase; endcase casez casex (ir[7:4]) (z é don’t care) 4’bxx01: ... 4’bxx10: ... casex default: ... (z e x são don’t care) endcase (expression)?(true):(false) acc=(ir[7:0]==4’b0011) ? 0 : 255; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 53 José Carlos Alves ciclos (utilização restrita em modelos sintetizáveis) for(start;end_expr;update) for(i=0;i<8;i=i+1) statement; x[i] = x[i+1] while(condition) while(i<8) statement; begin ... end repeat(10) repeat(fixed_loop_count) begin statement; a[i]=a[i+1]; i=i+1; end; forever statement; forever #10 clock = ~clock; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 54 José Carlos Alves
- 28. modelação de circuitossíncronos • 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; reg_sum “segura” um valor lógico always @( negedge clk ) if ( reset ) processo reg_sum <= 8’d0; síncrono com clk sempre que clk else reg_sum <= a + reg_sum; endmodule reset D Q reg_sum a 0 clk FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 55 José Carlos Alves 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; processo combinacional output end_count; assign end_count = enable & (down ? (dout==0) : (dout==15) ); always @( posedge clk or posedge reset) begin if ( reset ) dout <= 0 else processo síncrono begin com o flanco ascendente if ( enable ) de clk e reset assíncrono if ( down ) dout <= dout – 1; a avaliação do sinal de reset else tem de ocorrer no início do dout <= dout + 1; bloco begin...end end end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 56 José Carlos Alves
- 29. testbench para ocontador up/down `timescale 1ns/100ps module updown_counter_testbench; reg clk, reset, enable, down; wire [3:0] dout; instância do contador 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 estímulos #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; sinal de always #5 clk = ~clk; // 10ns clock period relógio endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 57 José Carlos Alves atribuições blocking/nonblocking • Atribuições procedimentais – avaliadas em sequência Admitindo que in0=4,in1=4,acc=1 begin a1=4, b1=4, y1=8 a1=in0+in1-acc; y1=a1+b1; a1 = 4+4-1 = 7; z1=y1+a1; y1 = 7+4 = 11; end z1 = 11+7 = 18; • Atribuições non-blocking – avaliadas em paralelo begin a1<=in0+in1-acc; a1 = 7; y1<=a1+b1; y1 = 4+4 = 8; z1<=y1+a1; z1 = 8+4 = 12; end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 58 José Carlos Alves
- 30. 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) always @(posedge clk) begin begin ... ... if ( dataready ) if ( rdy ) rdy = 1; begin ... reg = datain; end ack = 1; end end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 59 José Carlos Alves blocos sequenciais e paralelos begin // sequencial begin x = k; x = k; inicia bloco paralelo #10 y = a + b; fork #5 z = y * x; #10 y = a + b; avaliadas em paralelo end #5 z = y * x; join end termina bloco paralelo 10 5 10 x x y y z z 5 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 60 José Carlos Alves
- 31. parametrização • módulos com parâmetros module my_multiply(...); parameter size=16, delay=5; ... endmodule valores por omissão my_multiply #(8,2) mult1(...); valores atribuídos à instância mult1 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 61 José Carlos Alves Modelação de máquinas de estados • FSM (Finite State Machine) – sequência determinada de estados, síncronizado com relógio – estrutura geral saídas (Moore) entradas saída saídas (Mealy) saída saídas (Moore) próximo reset estado (síncrono) registo de clock estado reset (assíncrono) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 62 José Carlos Alves
- 32. Modelação de máquinasde estados • Codificação de estados (feita “à mão”) – 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 ... FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 63 José Carlos Alves Máquinas de estados - Mealy e Moore • Mealy – as saídas dependem do estado corrente e das entradas – o valor das saídas é associado às transições entre estados i1 i1/s1 condição de A B transição de estado C • Moore i2/s2 valores das – as saídas dependem apenas do estado corrente saídas – o valor das saídas é associado aos estados i3 s3 i3 s3 E D i4 F s4 FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 64 José Carlos Alves
- 33. Máquinas de estados- especificação • Tabela de transição de estados 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 • Diagrama de transição de estados Ymo 0 1 Ymo 1X/0 i1/Yme 00 01 i1/Yme S1 S0 0X/1 X1/0 i2/Yme X0/1 i2/Yme XX/1 Yme i1 i2/Yme 10 saídas Mealy S2 1 saídas Moore Ymo FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 65 José Carlos Alves Máquinas de estados - modelação em Verilog module FSM_mal(clock, i1, i2, Yme, Ymo); • Modelo incorrecto input clock, i1, i2; output Yme, Ymo; reg Yme, Ymo; reg [1:0] state; always @(posedge clock) Ymo 0 1 case (state) 1X/0 2’b00: begin 00 01 Ymo<=0; 0X/1 if (i1) X1/0 X0/1 begin XX/1 state<=2’b01; Yme<=0; end i1 i2/Yme 10 else 1 Yme<=1; end 2’b01: begin Ymo<=1; if (i2) begin state<=2’b00; Yme<=0; end else begin state<=2’b10; Yme<=1; Onde estão os erros ? end end 2’b10: begin Ymo<=1; state<=2’b00; Yme<=1; end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 66 José Carlos Alves
- 34. Máquinas de estados- modelação em Verilog module FSM_mal(clock, i1, i2, Yme, Ymo); • Modelo incorrecto input clock, i1, i2; output Yme, Ymo; reg Yme, Ymo; reg [1:0] state; always @(posedge clock) case (state) Ymo 0 1 2’b00: begin 1X/0 Ymo<=0; 00 01 if (i1) 0X/1 begin X1/0 state<=2’b01; Yme<=0; X0/1 end XX/1 else i1 i2/Yme 10 Yme<=1; 1 end 2’b01: begin Ymo<=1; if (i2) begin state<=2’b00; Yme<=0; • falta de reset (síncrono e/ou assíncrono) end else • todas as saídas são registadas begin state<=2’b10; Yme<=1; • Yme não é saída Mealy end end • não é definido o estado inicial 2’b10: begin • falta o estado 2’b11 Ymo<=1; state<=2’b00; Yme<=1; end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 67 José Carlos Alves Máquinas de estados - modelação em Verilog always @(state or i1 or i2) • Modelo correcto begin case (state) 2’b00: begin nextstate=2’b00; Ymo 0 1 Ymo=0; 1X/0 if (i1) 00 01 begin 0X/1 nextstate=2’b01; Yme=0; X1/0 X0/1 end else XX/1 Yme=1; i1 i2/Yme 10 end 1 2’b01: begin Lógica de geração Ymo=1; if (i2) Memória de estado do próximo estado begin e das saídas nextstate=2’b00; Yme=0; end else module FSM_bem(reset, clock, begin i1, i2, Yme, Ymo); nextstate=2’b10; Yme=1; input reset, clock, i1, i2; end output Yme, Ymo; end reg Yme, Ymo; 2’b10: begin reg [1:0] state, nextstate; Ymo=1; nextstate=2’b00; Yme=1; end always @(posedge clock) default: begin if (reset) Ymo=0; nextstate=2’b00; Yme=1; state<=2’b00; end else end state<=nextstate; endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 68 José Carlos Alves
- 35. Máquinas de estados- modelação em Verilog • Separação da lógica do próximo estado das saídas always @(state or i1 or i2) begin always @(state or i1 or i2) case (state) begin 2’b00: begin case (state) Ymo=0; 2’b00: if (i1) if (i1) nextstate=2’b01; Yme=0; else else nextstate=2’b00; Yme=1; 2’b01: begin end if (i2) 2’b01: begin nextstate=2’b00; Ymo=1; else if (i2) nextstate=2’b10; Yme=0; end else 2’b10: nextstate=2’b00; Yme=1; end default: nextstate=2’b00; 2’b10: begin Ymo=1; Yme=1; end end endmodule default: begin Ymo=0; Yme=1; end end endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 69 José Carlos Alves Máquinas de estados - modelação em Verilog • Combinando estado corrente e próximo estado always @(posedge clock or negedge reset) begin if (!reset) modelando Ymo como saída síncrona: state <= 2’b00; else always @(posedge clock or negedge reset) case (state) begin 2’b00: if (i1) if (!reset) state<=2’b01; begin else Ymo<=0; state<=2’b00; state <= 2’b00; 2’b01: begin end if (i2) else state<=2’b00; case (state) else 2’b00: if (i1) state<=2’b10; begin end Ymo<=1; 2’b10: begin state<=2’b01; state<=2’b00; end end else default: begin begin state<=2’b00; Ymo<=0; end state<=2’b00; end end endmodule ... FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 70 José Carlos Alves
- 36. Síntese de SistemasDigitais alto nível (behavioral) RTL estrutural comportamental lógica processadores, fluxogramas, memórias algoritmos registos, muxs circuito transferências entre registos portas lógicas expressões booleanas transistores funções de transistores di sp layout de os i transistores tiv o ló gi ã o co cç células RT si ra L st st ab em a módulos, chips d e is ve placas, MCMs ní físico FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 71 José Carlos Alves Problemas de síntese • Síntese estrutural – do domínio comportamental para o domínio estrutural – dependente da tecnologia, não define a realização física – sujeita a restrições como área, desempenho, potência,… • Síntese física – transformação do domínio estrutural para o domínio físico: • dispositivo: produção dos desenhos das máscaras de células (layout) • célula: colocação de células e interligações (place & route) • RTL: organização física de módulos (floorplanning) • sistema: particionamento em componentes, PCBs, MCMs FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 72 José Carlos Alves
- 37. Síntese RTL • origem – descrição comportamental ao nível RTL (ou lógico) • variáveis (registos) • operações entre variáveis (aritméticas, lógicas, deslocamento de bits) • decisões (if-then-else, case) • transferências entre registos síncronas com sinais de relógio – restrições de implementação • frequência mínima do sinal de relógio • espaço ocupado: número e tipo de células (FPGAs) ou área física (ASICs) • destino – um modelo estrutural ao nível lógico • antes do mapeamento tecnológico: portas lógicas, flip-flops, latches • após a optimização para a tecnologia alvo: rede de células disponíveis da tecnologia FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 73 José Carlos Alves Síntese RTL • Como é traduzido o código? – cada módulo é sintetizado para uma tecnologia genérica • pode ser realizada alguma optimização lógica nesta fase – o circuito é posteriormente optimizado para a tecnologia alvo • são usadas apenas células que existam na biblioteca alvo • optimização da utilização dessas células (área ou rapidez) • pode ser mantida a hierarquia ou ser “planificado” num só nível – as construções Verilog são traduzidas em circuitos padrão: • if-then-else – multiplexers 2÷1 • case-endcase – multiplexers “grandes” (ou lógica random) • always @(posedge clk ... ) – circuitos síncronos com clk • assign ou always @(a or ... ) – circuitos combinacionais • operadores aritméticos e lógicos – circuitos combinacionais FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 74 José Carlos Alves
- 38. Síntese RTL –estilo de codificação • O “estilo” de codificação afecta o resultado – Dependente da ferramenta de síntese (ler os manuais!) • as ferramentas têm directivas que “guiam” o processo de síntese – Estrutura de circuitos combinacionais gerados por expressões • depende da associação de operadores: • a*(b+c+d+e) • a*((b+c)+(d+e)) • a*(b+c)+a*(d+e) – Codificação de FSMs • codificação de estados é feita explicitamente pelo projectista – a codificação adoptada afecta muito a qualidade do resultado • obtêm-se melhores resultados dividindo uma FSM em vários blocos – próximo estado, saídas, timers, ... FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 75 José Carlos Alves Modelos RTL sintetizáveis (regras genéricas suportadas pelas ferramentas de síntese) – Atrasos são sempre ignorados • o seu uso pode tornar incoerente a simulação e o comportamento do circuito – Sinais do tipo reg • nem sempre são traduzidos em registos • podem ser traduzidos em wire, D-flip-flops ou latches transparentes – Atribuição contínua (assign sum=a^b^cin;) • traduzida para um bloco de lógica combinacional – Operadores aritméticos e lógicos • inteiros sem sinal, dimensão dos resultados depende dos operandos • são criados circuitos combinacionais que os implementam • podem ou não ser partilhados para diferentes operações do mesmo tipo FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 76 José Carlos Alves
- 39. Construção de modelossintetizáveis – always - duas formas • always @(posedge ...): os sinais tipo reg são traduzidos para FFs tipo D always @(posedge clock or negedge reset) begin if (!reset) acc = 8’b00000000; reset assíncrono; else tem de ser avaliado acc = data_in; no primeiro if(...) end • always @(a or b or ...): sinais do tipo reg são latches ou wires always @(a or sel) always @(a or b or sel) lista de sensibilidades begin begin if (sel) if (sel) out = a; out = a; end else out = b; end out é uma latch out é uma função combinacional de sel, a e b FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 77 José Carlos Alves Construção de modelos sintetizáveis – inferência de latches em circuitos combinacionais com construções always - regra geral • latches são geradas para sinais do tipo reg que não sejam completamente especificados para todos os casos de instruções condicionais (por exemplo if (sel) out = a; e quando sel==0 ? ) • no caso contrário é apenas gerado um circuito combinacional sem elementos de memória – latches são (geralmente) indesejáveis e fatais • como podem afectar o funcionamento de um circuito síncrono?! – ferramentas de síntese ignoram a lista de sensibilidades • em construções do tipo always @( enable or bus_a or bus_b) • o simulador não: só avalia o bloco quando algum sinal muda de estado • um modelo pode simular mal mas o circuito resultante funcionar bem! FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 78 José Carlos Alves
- 40. Construção de modelossintetizáveis – inferência de buffers de 3-estados • atribuindo z a um sinal (do tipo reg) module three_state(in, out, en); input in, en; output out; reg out; always @( in or en) if (en) out = in; else assign out = en ? in : 1’bz; out = 1’bz; endmodule FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 79 José Carlos Alves Construção de modelos sintetizáveis – ciclos • for(...): só são suportadas 4 formas: – crescente ou decrescente de passo constante (...;index=index±step) – condição de terminação com <, >, <= ou >= always @( a or b or carry ) for(i=0;i<=31;i=i+1) begin s[i] = a[i]^b[i]^carry; carry = a[i]&b[i] | a[i]&carry | b[i]&carry; end • while (...): cria um ciclo combinacional; deve ser quebrado com @(posedge clock) always @( posedge clock ) while (x<y) begin @(posedge clock); x=x+z; end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 80 José Carlos Alves
- 41. Verificação do projecto • Verificação funcional – processo para demonstrar a correcção funcional de um modelo • que estímulos para garantir que o modelo está funcionalmente correcto? • Importância da verificação (multi-million gate…) – consome tipicamente 70% do esforço do projecto – N Engs para projecto RTL mas 2N para verificação – os testbenches representam até 80% do volume total de código – verificação está no caminho crítico de um projecto • Reduzir o custo da verificação – explorar paralelismo e a reutilização dos processos – criar testbenches a níveis de abstracção elevados (>RTL, eg. Matlab) – minimizar o factor humano (que é a verdadeira fonte de erros!) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 81 José Carlos Alves Verificação de um modelo Testbench DUV Design Under Verification estímulos saídas FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 82 José Carlos Alves
- 42. O “factor humano”na verificação Codificação RTL Interpretação Especificação O mesmo projectista Modelo RTL Factor humano Verificação A verificação não é feita contra a especificação original O processo pode ser “viciado” se apenas existir uma só interpretação É (mais ou menos…) normal as especificações conterem ambiguidades FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 83 José Carlos Alves Como reduzir o factor humano? • Automatização – Criar procedimentos que verifiquem o projecto automaticamente (!) • quem faz esses procedimentos? • Redundância – dois projectistas: um projecta o sistema e o outro verifica – cada um tem uma interpretação da especificação Interpretação A Codificação RTL Especificação Projectista A Modelo RTL Projectista B Verificação Interpretação B FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 84 José Carlos Alves
- 43. Processos de verificação • Verificação formal – usa processos formais para provar características de um modelo • verificação da equivalência entre modelos (equivalence checking) • verificação que um modelo satisfaz condições (model checking) • Verificação funcional – pretende provar que o modelo RTL satisfaz a especificação • pode-se mostrar que é satisfeita a funcionalidade ensaiada • mas é impossível provar que é satisfeita a especificação (informal...) • Geração de testbenches – geram estímulos para verificar certas propriedades do modelo • por exemplo, tentar violar uma propriedade FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 85 José Carlos Alves Verificação da equivalência (equivalence checking) • Verifica se dois modelos RTL/estruturais são equivalentes – verifica dois netlists após algum pós-processamento automático (ou manual) • por exemplo, inserção da cadeia de scan (para construir a infraestrutura de teste) – verifica se o netlist produzido pela síntese é equivalente ao modelo RTL • o modelo pode estar mal codificado, as ferramentas de síntese podem ter bugs – permite verificar se um modelo RTL representa um netlist já existente síntese / modificação manual RTL/netlist RTL/netlist Verificação da equivalência FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 86 José Carlos Alves
- 44. Verificação do modelo (model checking) • Verifica se o modelo satisfaz condições/afirmações – as condições a verificar são sujeitas a interpretação • exemplo de condições: – todos os estados de uma FSM são atingidos? não ocorre deadlock? – um interface responde correctamente sob condições dadas? – problema: identificar na especificação que condições verificar... codificação RTL RTL especificação condições afirmações Verificação interpretação do modelo FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 87 José Carlos Alves Verificação funcional • Verifica se o modelo realiza a funcionalidade especificada – a tradução da especificação para o código RTL é feita por humanos • é um processo manual “naturalmente” sujeito a erros – especificações são (geralmente) representadas em linguagens informais • com ambiguidades, sujeitas a diferentes interpretações – apenas se garante a correcção da funcionalidade ensaiada codificação RTL especificação RTL Verificação funcional FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 88 José Carlos Alves
- 45. Geração de testbench •geração automática de estímulos para simulação – com base em medidas de cobertura de código (code coverage) • que construções do código RTL são ensaiadas para um conjunto de estímulos? • que estímulos são necessários para activar e verificar parte do código? – é o projectista que deve verificar os resultados da simulação – os estímulos produzidos não verificam a funcionalidade do projecto cobertura do código métricas RTL testbench geração de testbench FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 89 José Carlos Alves Prototipagem • Verificação por prototipagem (o DUV é hardware físico) – como construir um protótipo de um ASIC? • componentes off-the-shelf • que nível de equivalência? funcional, RTL ou lógico? • sistemas baseados em FPGAs (oferecem actualmente milhões de gates…) – o testbench é hardware (fontes de sinal, analisadores lógicos...) – características eléctricas e dinâmicas são diferentes da tecnologia alvo • o processo de validação tem de conseguir “absorver” essas diferenças – funcionamento em tempo real (ou quase) – possibilita verificação com estímulos complexos de sistemas físicos • disponíveis em tempo real, mas difíceis de modelar • exemplo: sistemas de controlo de processos físicos FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 90 José Carlos Alves
- 46. Simulação • Verificação porsimulação (DUV é um modelo informático) – menor rapidez mas maior flexibilidade do que prototipagem • observar o estado de qualquer nó ou componente • forçar sinais a estados desejados • parar e reiniciar a simulação em qualquer estado • controlar de forma precisa a temporização de eventos assíncronos – verificação funcional realiza-se em diferentes estágios do projecto • RTL, pós-síntese (gate-level), pós-layout (verificação temporal) – diferentes modelos de atrasos • fornecidos nas bibliotecas que caracterizam a tecnologia alvo – simulação de faltas • construção de conjuntos de estímulos para detectar defeitos • estimulam o circuito para “ver” o efeito de defeitos nas saídas FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 91 José Carlos Alves Simulação - problemas • Como se constroem estímulos ? – não há procedimentos formais para gerar estímulos – processo heurístico, baseado na intuição e conhecimento do sistema – não é praticável a verificação exaustiva • circuito com 75 entradas ⇒ 275 testes (1.2x103anos@1us/teste) • Como se sabe se os resultados são correctos ? – só verifica a funcionalidade exercitada pelos estímulos – o modelo simulado é uma aproximação • Estímulos para verificação e para teste – verificação: detectar e diagnosticar erros de projecto • não é possível enumerar todos os erros de projecto – teste: detectar e diagnosticar defeitos de fabrico • defeitos de fabrico (faltas) são modelados como erros lógicos FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 92 José Carlos Alves
- 47. Simulação compiled code • executa um modelo compilado do circuito – o circuito é traduzido em instruções de um processador – apenas para verificação funcional; não suporta análise temporal – o comportamento de componentes é modelado por subrotinas – adequado para simular o comportamento de sistemas síncronos – permite realizar simulações cycle based (resposta para cada ciclo de clk) para cada transição de clk (código x86): D MOV AL,A Q AND AL,B A Z Y MOV Y,AL D MOV AL,B B Q AND AL,Y F MOV AH,AL clk NOT AL MOV Z,AH MOV F,AL FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 93 José Carlos Alves Simulação cycle based • simulação de sistemas exclusivamente síncronos – só interessa conhecer o estado das entradas D dos FFs – todas as funções combinacionais são traduzidas em equações lógicas – apenas são simuladas as transferências entre registos • sincronizadas com um único flanco do relógio – simuladores cycle based não suportam • qualquer informação temporal associada ao circuito – É assumido que são satisfeitos todos os requisitos temporais dos FFs • entradas assíncronas • latches • circuitos com múltiplos domínios de relógio – análise temporal realizada com ferramentas de análise estática • que também só se podem aplicar a circuitos síncronos FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 94 José Carlos Alves
- 48. Simulação event-driven • simulaçãode eventos – um evento é uma mudança do estado de um sinal num tempo dado • os componentes que usam esse sinal são activados e avaliados • as mudanças resultantes dessas avaliações geram novos eventos – usa um modelo do circuito para gerar e propagar eventos • eventos nas entradas primárias são produzidos pelos estímulos • eventos nos restantes nós são gerados pela avaliação dos componentes – permite processar estímulos e sinais assíncronos • análise do comportamento com os atrasos dos componentes • avaliação do funcionamento com eventos não sincronizados FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 95 José Carlos Alves Simulação event-driven todos os eventos produzidos pelos início estímulos já foram introduzidos na lista avançar tempo até ao próximo de simulação evento pendente actualiza o valor dos extrair eventos não há eventos sinais modificados para este tempo pelos eventos deste tempo actualiza sinais fim activos propaga o valor dos sinais activos até aos componentes que os usam e activa esses propaga mudanças dos sinais componentes avalia componentes a avaliação dos componentes activados activados produz novos eventos em tempo futuro (atrasos dos introduz os novos componentes) ou no mesmo tempo eventos na lista FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 96 José Carlos Alves
- 49. Simulação event-driven initial O que acontece neste caso? begin initial a=2; b=3; c=1; begin #25 c=2; a=2; b=3; #10 end lista de eventos a=4; b=6; #10 a=6; b=8; #10 $stop; always @(a or b or c) end begin #5 z=a+8; always @(a or b) #10 y=b+c; begin #4 k=z+y; a=a+b end end Δ c=x c=1 b=x b=3 a=x a=2 z=a+8 y=b+c k=z+y c=2 y=b+c t t=0 t=5 t=15 t=19 t=25 t=40 eventos agendados e extraídos por ordem FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 97 José Carlos Alves co-simulação • cooperação de dois simuladores num só ambiente – simuladores cycle based e event driven • um simula as partes síncronas, outro as partes não síncronas • ganho de rapidez em relação a um simulador (só) event driven • percorrem o eixo dos tempos (de simulação) em simultâneo – simuladores de Verilog e VHDL (ou outras linguagens) • um simulador para cada linguagem num ambiente integrado • permitem simular modelos mistos (DUV em Verilog, testbench em VHDL) • simuladores mixed-language – VHDL e Verilog traduzidas para um código intermédio (object code) – um só simulador simula esse modelo intermédio FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 98 José Carlos Alves
- 50. Simulação interpretação do valor lógico desconhecido • Quando um circuito lógico é ligado, – memórias e flip-flops ficam com valores lógicos não definidos – é necessário prever um mecanismo de iniciação (reset) • em circuitos “reais” está geralmente associado ao power-up • Valor lógico desconhecido: u (em Verilog é representado por x) – representa o estado de sinais lógicos não iniciados resultantes de • não iniciação de registos e memórias • indefinição do estado de entradas primárias do circuito a simular • resultantes de contenções em barramentos – é processado juntamente com os valores lógicos 0 e 1 • operadores lógicos são generalizados para tratar o valor lógico u FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 99 José Carlos Alves Simulação interpretação do valor lógico desconhecido • Tabelas de verdade para AND, OR e NOT AND 0 1 u OR 0 1 u NOT 0 1 u 0 0 0 0 0 0 1 u 1 0 u 1 0 1 u 1 1 1 1 u 0 u u u u 1 u • Perda de informação propagando o valor lógico u não serve usar u e u desconhecidos, mas sempre 0 com valores contrários Q u u u u u é sempre 1 Q u 1 u u Q 1 u Q desconhecido FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 100 José Carlos Alves
- 51. Simulação o valor lógico Z • Modelação de buffers com saída de alta impedância E I O Tabela de verdade de um barramento com 2 entradas o a b 0 1 Z u Tabela de verdade: a 0 0 u 0 u I E 0 1 u 1 u 1 1 u 0 Z 0 {0,Z} b Z 0 1 Z u 1 Z 1 {1,Z} u u u u u u Z u {u,Z} em que casos pode ocorrer contenção no barramento ? • Um sinal com o nível lógico Z – pode ser forçado com 1 ou 0 (pull-up ou pull-down) – é sempre interpretado como u por uma entrada FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 101 José Carlos Alves Simulação - modelos de atrasos • atraso de transporte – um atraso na propagação do nível lógico • atrasos de subida e de descida – diferentes atrasos para as transições 0-1 e 1-0 • atrasos ambíguos – mínimos e máximos para os atrasos 0-1 e 1-0 • atraso inercial – duração mínima de uma entrada para ser propagada para a saída • setup time e hold time (em flip-flops) – setup time: tempo mínimo para D estar estável antes de clock – hold time: tempo mínimo para D permanecer estável após clock FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 102 José Carlos Alves
- 52. Estratégias de verificação •Que abordagens de verificação? – qual o nível de granulosidade dos elementos a verificar? – há ou não acesso e conhecimento da implementação interna? • Como são verificadas as respostas? – análise visual de formas de onda não é (geralmente) praticável – comparação de dados armazenados em ficheiros • Produzidos off-line por processos de confiança (nível mais elevado) – incluir no próprio testbench o processo de verificação das saídas • “executando esta sequência de instruções sei que no instante t=134ns R1 deve ter 35, R5 deve ter 4, ..., o PC deve ficar com A7B4,… senão ocorreu um erro” mas qual, onde e porquê? FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 103 José Carlos Alves Estratégias de verificação • Verificação aleatória – não significa “atirar” aleatoriamente zeros e uns para as entradas! – aplicados estímulos que realizem aleatoriamente operações bem definidas e realistas na operação do sistema • sequências de transacções num barramento com dados aleatórios – possibilita a ocorrência de situações não previstas – devem ser contempladas as estatísticas de operações e dados – problema: como se podem prever as respostas? • analisando as respostas off-line • comparando com respostas de modelos mais abstractos já validados • comparando com respostas de modelos em simulação FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 104 José Carlos Alves
- 53. Planeamento da verificação •identificar as propriedades que interessa verificar – a partir da especificação do sistema a projectar – os projectistas podem também sugerir verificações – definir a que nível deve ser verificada cada propriedade • em modelos comportamentais de componentes em desenvolvimento? – verificar a funcionalidade contra a especificação • num modelo estrutural com componentes já validados? – verificar “apenas” as interconexões entre esses componentes • definir testes para verificar cada propriedade – exemplo: para validar o modelo de um filtro digital: • resposta ao impulso unitário (calcular FFT - resposta em frequência) • resposta com degraus positivos e negativos, sinusóides com comp. DC FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 105 José Carlos Alves Planeamento da verificação • agrupar testes com requisitos semelhantes – um único teste pode verificar todas as operações de uma ALU – um teste deve verificar o funcionamento de um CPU... – ...e outro teste deve verificar o funcionamento da memória cache • verificações podem necessitar de novos recursos – design-for-verification: instrumentar modelos para facilitar o processo de verificação (+ controlabilidade/observabilidade) • permitir “carregar” contadores longos (como validar um RTC?) • incluir mecanismos para inserção automática de “erros” • gerar estímulos em função das respostas do modelo • construir testbenches para cada grupo de testes – uma equipa de verificação responsável por um grupo de testes – exige cooperação com as outras equipas de verificação e projecto FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 106 José Carlos Alves
- 54. Verilog geração de sinais periódicos reg clk `timescale 1ns/1ns parameter CYCLE=10; reg clk parameter CYCLE=15; initial clk = 1’b0; always begin always #(CYCLE/2.0); clk = 1’b0; begin #(CYCLE/2.0); clk = 1’b1; #(CYCLE/2); clk = ~clk; end end `timescale 1ns/100ps reg clk parameter CYCLE=15; always Diferenças? begin #(CYCLE/2.0); clk = 1’b0; #(CYCLE/2.0); clk = 1’b1; end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 107 José Carlos Alves Sincronização de estímulos • geração de sinais (des)sincronizados – problema: ocorrência de condições de competição (race conditions) initial // apply reset begin rst = 1’b0; #200 clk rst = 1’b1; #200 rst = 1’b0; end rst always begin #50 clk = 1’b0; #50 clk = 1’b1; possibilidade de competição entre clk e reset end O que acontece se reset for síncrono com o negedge de clk ? – solução: não usar flancos sobrepostos! E num circuito “real” ? FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 108 José Carlos Alves
- 55. Sincronização de estímulos initial // apply reset begin // for 2 clocks rst <= 1’b0; clk clk <= 1’b0; repeat (2) #50 clk <= ~clk; rst rst <= 1’b1; repeat (4) #50 clk <= ~clk; não ocorre competição rst <= 1’b0; reset muda ao mesmo tempo que clk; forever #50 clk <= ~clk; quando clk troca, rst ainda tem o estado end anterior (atribuições non-blocking) FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 109 José Carlos Alves Entrada de dados de ficheiro • leitura de dados de um ficheiro de texto para um vector mem é um vector de registos, por exemplo: reg [15:0] mem[0:127] filename é o nome do ficheiro de texto que contém os dados os dados são em ASCII, representando números em binário ou hexadecimal podem ser incluídos comentários; posições não lidas ficam com ‘xxxx’ $readmemb( “filename”, mem, start_index, end_index); // binário //ficheiro de dados em binario @00 // endereço 0x00 (zero, em hexadecimal) 0000_0000_0000_0001 // dado, o caracter ‘_’ é um separador 0000_0000_0000_1000 @10 // os dados seguintes sao colocados a partir do endereço 0x10 0000000000001011 $readmemh( “filename”, mem, start_index, end_index); // hex //ficheiro de dados em hexadecimal @00 // endereço 0x00 (zero, em hexadecimal) 00_01 // dado, o caracter ‘_’ é um separador 0AFE @10 // os dados seguintes sao colocados a partir do endereço 0x10 FF_0B FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 110 José Carlos Alves
- 56. Saída de dadospara ficheiros de texto • $fopen, $fclose, $fmonitor, $fwrite, $fdisplay integer HI, HQ; // File handlers initial // open output files begin HI = $fopen(“dout_I.dat”); HQ = $fopen(“dout_Q.dat”); // simulate ... close files $fclose(HI); $fclose(HQ); end initial $fmonitor(fh,...); // $monitor para ficheiro always @(posedge clock) begin $fdisplay( HI, “%d”, HI); // inclui newline $fwrite( HQ, “%dn”, HQ); // nao inclui newline end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 111 José Carlos Alves Monitorização de valores • nomes hierárquicos – operador . (ponto) task dump_regfile; // dump CPU registers integer i; begin for(i=0;i<8;i=i+1) $display(“R%d=%d (%h)”, i, mycpu.regfile_1.regs[i], mycpu.regfile_1.regs[i] ) end initial begin // apply reset and check initial state $display(“Ctrl unit initial state: %b”, mycpu.ctrl_1.state); end mycpu sinal da instância ctrl_1 dentro de mycpu ctrl_1 reg [4:0] state; FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 112 José Carlos Alves
- 57. Geração de númerosaleatórios • geração de estímulos aleatórios (valor ou tempo) $random(seed); // inicia o gerador de números aleatórios x = $random; // retorna um inteiro aleatório (32 bits) x = $random / 32’h0fff_ffff; // inteiro entre [0..15] • especificação de atrasos não constantes: #( expressão ) integer x; reg [15:0] y; reg [7:0] cmd; x = $random / 32’h00ff_ffff; y = $random / 32’h0fff_fffa; cmd = $random / 32’h3fff_ffff; for(i=0; i<MAXLOOP; i=i+1) begin #(x) apply_initcommand; #(x*y/3) send_command( cmd, data); end FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 113 José Carlos Alves tasks • Sub-rotinas em Verilog – Interesse particular para a construção de testbenches – Podem conter atrasos, chamadas a outras tasks task writecommand; input [15:0] data; // data to write input [1:0] address; // address of output port begin din = {4'b0010, 2’b00, address}; // compose and write command load = 1; #10 load = 0; #10 // ld for 1 clock din = data[15:8]; // send MS byte load = 1; #10 load = 0; #20 // ld for 2 clocks din = data[7:0]; // send LS byte load = 1; #10 load = 0; #30 load = 0; end initial endtask begin … writecommand(16'h39A6, 2'b00 ); FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 114 José Carlos Alves
- 58. Verilog PLI • PLI – Programming Language Interface – Ligação do simulador de Verilog a programas em C – Acesso aos dados da simulação (escrita e leitura) – Construção de tasks específicas para tarefas de “alto nível” • Link for ModelSim – Toolbox do MatLab para simulação conjunta MatLab-Modelsim Tutorial em: http://www.asic-world.com/verilog/pli.html FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 115 José Carlos Alves Co-simulação MatLab-ModelSim http://www.mathworks.com/products/modelsim/description1.html FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007 116 José Carlos Alves