verilog_wshp_direto

Prévia do material em texto

Workshop de Verilog
MsC. Cezar Reinbrecht
LINGUAGEM VERILOG
Workshop em Verilog
Descrição Estrutural - Netlist
• Representação 
para portas lógicas 
puras.
• Resultado da etapa 
de síntese lógica.
Descrição Comportamental
• Nível Modelamento/Algorítmico
– Representação sem considerações de 
temporização.
– Preocupação apenas com algoritmo de solução.
• RTL ( Register Transfer Level)
– Representação com consideração temporal na 
transição entre registradores do tipo flip-flop.
– Preocupação da descrição comportamental com o 
hardware a ser implementado
Tipos de Dados e Representação
• Tipos
– 0 – Zero
– 1 - Um
– X – Indefinido ou Conflito Lógico (curto-circuito)
– Z – Alta impedância
• Representação Númerica
#BITS ’ BASE NUMERO
– Exemplo:
8’b00001010 8’o12
8’d10 8’h0A
Classe de Sinais
• NETS
– Atribuições não-procedurais, ou seja, sinais que são 
atribuídos fora de processo.
• WIRE (PADRÃO)
• REGISTER
– Atribuições procedurais, ou seja, sinais que são atribuídos 
dentro de processos.
– CUIDADO!!! REGISTER não significa lógica sequencial.
• REG
Atribuições
• Atribuição Contína
wire a;
assign a = b + c;
• Atribuição Procedural
reg a;
always @(*)
begin
a = b + c; 
end
+
b
c
a
Seleção, Concatenação e 
Replicação de Bits
• Seleção
– Sinal [BMS:bms]
– Exemplo:
assign operando = instruction[10:0];
assign opcode = instruction[15:11];
• Concatenação
– Sinal = {Sinal_A,Sinal_B,...}
– Exemplo:
assign imm = {5’b00000,operando};
• Replicação
– {Quantidade{Sinal/Valor}}
– Exemplo
assign imm = {16{1’b0}};
///Exemplo Extensor de Sinal
wire [15:0] imm;
assign imm = { {5{operando[10]}}, operando};
Definição do Módulo
• Definir o nome do módulo a ser projetado, 
bem como, suas interfaces.
XUXU
module xuxu (
input A,
input B,
input C,
output S
);
/// CORPO 
endmodule
A
B
C
S
Interfaces
• Ao definir as interfaces deve-se:
– Definir o sentido da conexão:
• Input – Entrada
• Output – Saída
• Inout – Entrada e saída (apenas casos muito específicos)
– Definir o tamanho da conexão:
• 1 bit – Padrão, não é necessário descrever nada
• N Bits – utilizar [BMS : 0]
• Exemplo
input [7 : 0] A //entrada A de 8 bits
output [31 : 0] S //saída S de 32 bits
*BMS – BIT MAIS SIGNIFICATIVO
Parâmetros
• Constante utilizada 
para parametrizar a 
implementação.
• Quando o módulo for 
instanciado, entidade 
que chama pode 
alterar os parâmetros.
module xuxu
#(
parameter A = 3,
parameter TAM = 8
)
(
input A,
output [ (tam-1) : 0] S
);
/// CORPO 
endmodule
Instanciação
• Invocar outro módulo dentro do módulo em 
desenvolvimento.
decoderdecoder
somadorsomador
Módulo ULA
OP
A
B
RES
module xuxu (
input [7:0] A,
input [7:0] B,
input [2:0] OP,
output [7:0] RES
);
wire mode;
decoder unidade1 ( .codigo(OP), .mode(mode));
somador unidade2 ( .a(A), .b(B), .enable(mode));
endmodule
mode
Unidade 1
Unidade 2
Lógica Combinacional
module always_c (
input mode, 
input a,
output reg c
);
always @ (*)
begin 
if (mode == 1) 
c = a + 1; 
else 
c = a - 1;
end
endmodule
0
1
mode
a
1
a
1
c
mode
a
+
-
Lógica Sequencial
module always_c ( input clock,
input reset,
input mode, input a,
output reg c
);
always @ (posedge clock, posedge reset)
Begin
if ( reset ) //RESET SEMPRE NO 1o IF
c <= 0;
else
if (mode == 1) 
c <= a + 1; 
else 
c <= a - 1;
end
0
1
mode
a
1
a
1
c
mode
a
clk
+
-
Que elementos os diferenciam?
module always_c (
input mode, 
input a,
output reg c
);
always @ (*)
begin 
if (mode == 1) 
c = a + 1; 
else 
c = a - 1;
end
endmodule
module always_c ( input clock,
input reset,
input mode, input a,
output reg c
);
always @ (posedge clock, posedge reset)
Begin
if ( reset ) 
c <= 0;
else
if (mode == 1) 
c <= a + 1; 
else 
c <= a - 1;
end
endmodule
BLOCKING
NON–BLOCKING 
Testbench
• Mecanismo para 
verificar se o módulo 
projetado realiza 
corretamente as suas 
funções.
• Utiliza processo initial
– Processo que executa 
apenas uma vez
Delay e Timescale
• Delay
– #ATRASO
• Timescale
– Define:
• Unidade de tempo
• Precisão da simulação
– Colocar no testbench acima de module:
‘timescale 1ns/1ns ou ‘timescale 1ns/100ps
Exemplos Testbench
‘timescale 1ns/1ns
module main;
reg a, b, c; 
wire sum, carry;
Somador soma(a,b,c,res);
initial
begin
a = 0; b = 0; c = 0;
#5
a = 0; b = 1; c = 0;
#5
a = 1; b = 0; c = 1;
#5
a = 1; b = 1; c = 1;
• #5
end
endmodule
‘timescale 1ns/1ns
module main;
reg a, b, c; 
wire sum, carry;
Somador soma(a,b,c,res);
initial
begin
a = 0; b = 0; c = 0;
#5
a = 0; b = 1; c = 0;
#5
$display (“Resultado é %d”, res);
end
endmodule
Para mostrar no terminal as informações, use $display
DICAS DE IMPLEMENTAÇÃO
Workshop Verilog
MUX
0
1 c
mode
a
b
wire c;
assign c = mode ? a : b;
reg c;
always @(*)
begin
if (mode)
c = a;
else
c = b;
end
MUX Grande
2
3
e
mode
a
b
wire e;
assign e = ( mode[1] ? ( mode[0] ? a : b ) : ( mode[0] ? c : d) );
reg e;
always @(*)
begin
case (mode)
2’b00: e = d;
2’b00: e = c;
2’b00: e = b;
2’b00: e = a;
default: e = a;
endcase
end
1
0
c
d
Aritméticos e Lógicos
Operação Símbolo
Soma +
Subtração -
Multiplicação *
Divisão /
E bit-wise &
E lógico &&
OU bit-wise |
OU lógico ||
NÃO bit-wise ~
Não lógico !
Shift Right >>
Shift Left <<
Relacional Símbolo
Igual ==
Diferente !=
Maior que >
Menor que <
Maior ou igual >=
Menor ou igual <=
Flip-flop e Reset Parametrizável
reg [PARAM-1 : 0] q;
always @(posedge clock, posedge reset)
begin
if (reset)
q <= { PARAM { 1’b0 } };
else
q <= d;
end
q
clock
d
reset
Cuidado com Lógica Combinacional
always @ (*)
begin 
if (mode == 1) 
c = a + 1; 
end
mode
+
a
1
a
c
mode
X
LATCH NÃO
circuito combinacional
COMPLETO!!
precisa do else
Tranquilo na Lógica Sequencial
always @ (posedge clk, posedge reset)
begin 
if (reset)
c <= 0;
else 
if (mode == 1) 
c <= a + 1; 
end
1
0
mode+
a
1
a
c
mode clk
Não precisa do else
Instanciação com Parâmetros
module somador #(
parameter TAM = 8
)
(
input [TAM-1:0] A,
input [TAM-1:0] B,
output [TAM:0] S
)
…..
endmodule
module ula (…)
reg [31:0] V1, V2;
wire [32:0] RES;
somador #(.TAM(32)) inst0 (
.A(V1),
.B(V2),
.S(RES)
)
endmodule
Criar Clock no Testbench
reg clock;
always #10 clock = ~clock;
initial
begin
clock = 0;
end
always
begin 
clock = 0;
#5
clock = 1;
#5
end
Criar Memória para o Testbench
reg [7:0] mem [0:1023];
//PARA INICIALIZAR COM DADOS SE PRECISAR
$readmem(“memoria.txt”,mem);
always @(posedge clock)
begin
if (write_en)
mem[addr] <= data_in;
end
assign data_out = read_en ? mem[addr] : {TAM{1’b0}};
EXERCÍCIOS
Workshop em Verilog
Ferramenta – Coding Ground
• Tutorials Point
– Ir em www.tutorialspoint.com
– Escolher Coding Ground -> Online IDE
• Verilog
– Crie o projeto Meu_BIP
• Desenvolva os códigos e simule com terminal
http://www.tutorialspoint.com/
Ferramenta – Coding Ground
Exercício 1 – Módulo ULA
• Desenvolva o seguinte circuito combinacional
e seu testbench:
– A, B e S devem ser parametrizáveis
F Função
2’b00 Soma
2’b01 E
2’b10 Não B
2’b11 Subtração
Exercício 2 – Módulo Decoder
• Faça um Decodificador conforme regras da 
tabela abaixo e seu testbench:
Entrada Saídas
Código S0 S1 S2 S3 S4 S5
5’b00000 1’b0 2’b00 1’b0 1’b0 2’b00 1’b0
5’b00001 1’b1 2’b00 1’b0 1’b0 2’b00 1’b1
5’b00010 1’b1 2’b00 1’b0 1’b1 2’b00 1’b0
5’b00011 1’b1 2’b01 1’b0 1’b1 2’b00 1’b0
5’b00100 1’b1 2’b10 1’b0 1’b1 2’b00 1’b0
5’b00101 1’b1 2’b10 1’b1 1’b1 2’b00 1’b0
5’b00110 1’b1 2’b10 1’b0 1’b1 2’b11 1’b0
5’b00111 1’b1 2’b10 1’b1 1’b1 2’b11 1’b0
Exercício 3 – Módulo Acumulador
• Desenvolva o circuito sequencial abaixo e seu 
testbench:
– entradas e acumulador devem ser parametrizáveis
1
0 acumulador
WrACC clock
dir
reset
3
2
1
0
imm
Select
ula
0
Exercício 4 – Módulo Contador• Desenvolva o circuito sequencial abaixo e seu 
testbench:
– contador deve ser parametrizável
1
0 contador
WrPC clock
reset
+1
Exercício 5 – Módulo BIP
• Desenvolva o circuito abaixo, utilizando como 
palavra de dados 16 bits.
AcumuladorAcumulador
ULAULA
DecoderDecoder
ContadorContador
WrPC
S0
S1
S2
S3
S4
Código (5 bits)
Operando (11 bits)
Instrucao (16 bits)P_Addr (16 bits) D_Addr (16 bits)
Imm (16 bits)
Extensor 1 0
F
Select
WrACC
S5
Mode
Imm (16 bits)
D_RW
Imm (16 bits)
Data_In(16 bits)Data_Out(16 bits)
Módulo BIP
A (16 bits)
B (16 bits)
Dir (16 bits)
Dir (16 bits)
Exercício 5
• Testbench disponibilizado junto com material:
– Enderço:
• sites.ieee.org/sb-ufrgs/wkshop_verilog
– Contém:
• Testbench
• Programa em binário
• Dados em binário
• Descrição do Programa
Conclusão Exercícios
• Vocês acabaram de implementar e verificar um 
processador didático chamado BIP (Basic Instruction-
set Processor)
• Foi utilizado o BIP I, que possui 8 instruções apenas
• Em casa, estude o material em www.bipide.com.br e 
desenvolva em ordem o BIP II, o BIP III e o BIP IV. 
• A IDE disponibilizada permite criar programas em 
Assembly, testá-los e gerar os binários para atualizar 
o testbench.
http://www.bipide.com.br/
APÊNDICE A – PROJETANDO FSM
Workshop em Verilog
Projetando Máquinas de Estado
• Técnica dos Três Processos
1º Processo - State
module always_c (clk, reset, in1, out1);
parameter IDLE = 0;
parameter SETUP = 1;
parameter FININSH = 2;
always @ (posedge clk, posedge reset)
begin
if (reset)
state <= IDLE;
else
state <= next_state;
end
STATE
always @ (*)
begin
case (state) 
IDLE: begin
if ( entradas )
next_state = SETUP;
else
next_state = IDLE;
end
SETUP: next_state = FINISH;
FINISH: next_state = IDLE;
default: next_state = IDLE;
endcase
end
2º Processo – Next State
NEXT STATE
always @ (*)
begin
case (state) 
IDLE: begin
if ( entradas )
saídas = 1;
else
saídas = 0;
end
SETUP: next_state = saídas = 1;
FINISH: next_state = saídas = 0;
default: next_state = saídas = 0;
endcase
end
3º Processo - Outputs
OUTPUTS