Transpar Tema1a

UNIVERSIDAD DE CANTABRIA. GRUPO DE INGENIERÍA MICROELECTRÓNICA

Diseño y Verificación de Sistemas DigitalesIntroducción a Verilog

INTRODUCCIÓN A VERILOG

Objetivos

comprender el uso de un HDL en el diseño de sistemas digitales

estudiar Verilog como Lenguaje de Descripción de Hardware (HDL)



Bibliografía

1. J. Bhasker: “Verilog HDL synthesis: A practical primer”, Star Galaxy Publishing, 1998.

2. E. Villar y P. Sánchez: “Síntesis”, Capitulo 4 de L. Terés, Y. Torroja, S. Olcóz y E. Villar: “VHDL: Lenguaje estándar de diseño electrónico”, McGraw-Hill, 1998.

INTRODUCCIÓN A VERILOG



Simulación Lógica

SÍNTESIS AL NIVEL DE TRANSFERENCIA ENTREREGISTROS

Arquitectura RT

Circuito Lógico

PosicionamientoInterconexión

SíntesisRT-Lógica

Implementación

Retroanotación

Simulación RT

Optimización aritméticaIdentificación de elementos de memoriaCodificación de tiposExtracción de las funciones lógicasMinimización Lógica



NIVELES DE ABSTRACCIÓN

Señal

transición activa de la señal de relojSeñal

t

Simulación RT

Modelo de Computación: Tiempo discreto




Simulación LógicaSeñal

t

Señal

t

transición activa de la señal de reloj

Simulación RT

Modelo de Computación: eventos discretos

Simulación dirigida por eventos




Simulación Lógica

Señal

t

Señal

t


Simulación RT

Señal

t

Simulación Lógica

retroanotada


tiempo de‘set-up’

periodo de reloj - tiempo de ‘set-up’

camino crítico

ventana de comparación

corrección del diseño

valores compatibles

‘X’

‘1’

‘1’



SISTEMA DIGITAL A NIVEL RT

Entradasde Control

Entradasde Datos

Salidasde Control

Señalesde Control

Señalesde Estatus

Salidasde Datos

Unidadde

Control

Unidadde

Datos



SISTEMA DIGITAL A NIVEL RT

LógicaCombinacional

deControl

Registrode

Estado

reloj

resetset

Estadode Controlpróximo

Estadode Control

actual

Salidasde Control

Entradasde Control

Señalesde Control

Señalesde Estatus

LógicaCombinacional

y UnidadesOperacionales

Registrosde

Datos

reloj

resetset

Datospróximos

Valoresactuales en

registros

Salidasde Datos

Entradasde Datos



simulación síntesis

0 ‘0’ lógico ‘0’ lógico

1 ‘1’ lógico ‘1’ lógico

z (?) tri-estadotri-estado

(‘don’t care’ en sentencias ‘case’)

x desconocido ‘don’t care’

VALORES LÓGICOS

Interpretación en modelado y síntesis



MÓDULO

Entidad de diseño

Error

BpWWaitValid

Clear

Ejemplo

module Ejemplo (BpW, Error, Wait, Valid, Clear);

input Error, Wait, Valid, Clear;output BpW;...

endmodule



TIPOS DE DATOS

Nodos de red (‘net data types’)

wire Ax; // línea de un ‘bit’wire [4:0] Dak; // agrupación de 5 líneas

wire

línea

tri

idéntico a ‘wire’ (sólo informa de múltiples drivers)

supply0 y supply1

‘0’ ‘1’



TIPOS DE DATOS


wire

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wire BpW;

assign BpW = Error&Wait;

endmodule

Ejemplo



TIPOS DE DATOS


múltiples ‘drivers’

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wire BpW;

assign BpW = Error&Wait;assign BpW = Valid | Clear;

endmodule

Error&Wait 0101Valid | Clear 0011 BpW 0xx1



TIPOS DE DATOS


wor

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wor BpW;


endmodule

Error&Wait 0101Valid | Clear 0011 BpW 0111



TIPOS DE DATOS


wor

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wor BpW;


endmodule



TIPOS DE DATOS


wand

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wand BpW;


endmodule

Error&Wait 0101Valid | Clear 0011 BpW 0001



TIPOS DE DATOS


wand

Error

BpWWaitValid

Clear


input Error, Wait, Valid, Clear;output BpW;wand BpW;


endmodule



TIPOS DE DATOS

Registros

reg Ax; // registro de un ‘bit’reg [4:0] Dak; // registro de 5 ‘bits’

reg

integer

registros de hasta 32 ‘bits’ en complemento-2

la herramienta de síntesis debe sintetizar el tamaño mínimo

6

wire [1:5] Brq, Rbu;integer Arb;...Arb = Brq + Rbu;...

+

Brq

Rbu

Arb

5

5



TIPOS DE DATOS

Constantes

30 -2

decimal simple

32 ‘bits’ en complemento-2

formato con base

2’b10 6’d-4 ’d-10

[size]’base valuebase=h,H,o,O,b,B,d,D



TIPOS DE DATOS

Parámetros

constantes nominales

parameter RED = -1, GREEN = 2; // constantes decimales (32 bits en complemento-2)

parameter READY = 2’b01, BUSY = 2’b11, EXIT = 2’b10; // constantes de 2 ‘bits’



DESCRIPCION ESTRUCTURAL



DESCRIPCION PARAMETRIZABLE (0)



DESCRIPCION PARAMETRIZABLE (1)



SENTENCIAS DE ASIGNACIÓN

Asignación continua

assign

ErrorStop

Start

WaitValid

Clear

module Ejemplo (Stop, Start, Error, Wait, Valid, Clear);input Error, Wait, Valid, Clear;output Stop, Start;wire Stop, Start;

assign Stop = Error&Wait;assign Start = Valid | Clear;

endmodule

Ejemplo

sentencias

concurrentes




Asignación continua

retraso

ErrorStop

Start

WaitValid

Clear

module Ejemplo (Stop, Start, Error, Wait, Valid, Clear);input Error, Wait, Valid, Clear;output Stop, Start;wire Stop, Start;

assign #5 Stop = Error&Wait;assign #6 Start = Valid | Clear;

endmodule retrasos ignorados en síntesis




Asignación procesal

module Ejemplo (Preset, Count);input [0:2] Preset;output [3:0] Count;reg [3:0] Count;

always @ (Preset)begin

.

.

.

end

endmodule

sentencias

secuenciales





asignación bloqueante


always @ (Preset) Count = Preset + 1;

endmodule

Preset[2]

Preset[1]

Preset[0]

Count[0]

Count[1]

Count[3]

Count[2]





asignación no-bloqueante


always @ (Preset) Count <= Preset + 1;

endmodule

Preset[2]

Preset[1]

Preset[0]

Count[0]

Count[1]

Count[3]

Count[2]





las asignaciones dobles a un mismo objeto son un error

Count <= Preset + 1;...Count = Mask;

los retrasos se ignoran

#5 Count <= Preset + 1;...Count = #5 Mask;

retrasos ignorados en síntesis



OPERADORES

Operadores lógicos

expresiones de conmutación

~ complemento

& and

| or

^ xor

module FullAdder (A, B, Carryin, Sum, Carryout);input A, B, Carryin;output Sum, Carryout;

assign Sum = (A ^ B) ^ Carryin;assign Carryout = (A & B) | (B & Carryin) | (A & Carryin);

endmodule

A

B

Carryin

Carryout

Sum



OPERADORES

Operadores aritméticos

+, - signo

+ suma

- substracción

* multiplicación

/ división

% módulo



OPERADORES


net, reg: operaciones sin signo

module UnsignedAdder (Arb, Bet, Lot);input [2:0] Arb, Bet;output [2:0] Lot;

assign Lot = Arb + Bet;

endmodule

+

Arb

Bet

Lot

3

3

3



OPERADORES


integer: operaciones con signo

module SignedAdder (Arb, Bet, Lot);input [1:0] Arb, Bet;output [2:0] Lot;reg [2:0] Lot;

always @ (Arb or Bet)begin: addition

integer Arbint, Betint;

Arbint = - Arb;Betint = Bet;Lot = Arbint + Betint;

end

endmoduleBet

‘1’

Arb

+

Lot+

2

3 3

2

3



OPERADORES


‘carry’ y ‘borrow’

module carryborrow (Arb, Bet, Lot);input [3:0] CdoBus;output [3:0] Sum;output [4:0] OneUp;output [3:0] ShortOneUp;output Bore;

assign OneUp = CdoBus + 1;assign ShortOneUp = CdoBus + 1;assign (Bore, Sum) = CdoBus – 2;

endmodule

// OneUp[4] lleva el ‘carry’// se pierde el ‘carry’// Bore lleva el ‘borrow’



OPERADORES

Operadores relacionales

> mayor

< menor

<= menor o igual

>= mayor o igual



OPERADORES


net, reg: comparaciones sin signo

module GreatherThan (A, B, Z);input [3:0] A, B;output Z;

assign Z = A[1:0] > B[3:2];

endmodule

B

A

> Z



OPERADORES


integer: comparaciones con signo

module SignedGreatherThan (ArgA, ArgB, ResultZ);input [2:0] ArgA, ArgB;output ResultZ;reg ResultZ;integer ArgAInt, ArgBInt;

always @ (ArgA or ArgB)begin

ArgAInt = - ArgA;ArgBInt = - ArgB;ResultZ = ArgAInt > ArgBInt;

end

endmodule

‘1’

ArgB

‘1’

ArgA

+

>

+

ResultZ



OPERADORES


igualdad y desigualdad

module NotEquals (A, B, Z);input [0:3] A, B;output Z;reg Z;

always @ (A or B)begin: comparison

integer IntA, IntB;

IntA = A;IntB = B;Z = IntA !=IntB;

end

endmodule

= igual

!= distinto

A[0]

B[0]

Z

A[1]

B[1]A[2]

B[2]A[3]

B[3]



OPERADORES

Operadores de desplazamiento

desplazamiento lógico constante

module ConstantShift (DataMux, Address);input [0:3] DataMux;output [0:5] Address;

assign Address = (~ DataMux) << 2;

endmodule

<< desplazamiento izquierda

>> desplazamiento derecha

DataMux[0] Address[0]




Address[4]

Address[5]



OPERADORES

Operadores de desplazamiento

desplazamiento lógico variable

module VariableShift (MemDataReg, Amount, InstrReg);input [0:2] MemDataReg;input [0:1] Amount;output [0:2] InstrReg;

assign InstrReg = MemDataReg >> Amount;

endmodule

MemDataReg[0]MemDataReg[1]MemDataReg[2] InstrReg[0

]

InstrReg[1]

InstrReg[2]

Amount[0]

Amount[1]



OPERADORES

Operaciones con vectores

operaciones lógicas

module LogicalVectorOperations (A, B, C, Z);input [0:3] A, B, C;output [0:3] Z;

assign Z = (A & B) | C;

endmoduleC[0]

B[0]

A[0]

Z[0]

C[1]

B[1]

A[1]

Z[1]

C[2]

B[2]

A[2]

Z[2]

C[3]

B[3]

A[3]

Z[3]



OPERADORES


selección de partes

module Selection (A, B, RegFile, ZCat);input [3:0] A, B, RegFile;output [3:0] ZCat;

assign ZCat[3] = A[2];assign ZCat[2:1] = B[3:2];assign ZCat[0] = RegFile[3];

endmodule

A[2]

B[3]

B[2]

RegFile[3]

ZCat[3]

ZCat[2]

ZCat[1]

ZCat[0]



OPERADORES


concatenación

module Concatenation (A, B, RegFile, ZCat);input [3:0] A, B, RegFile;output [3:0] ZCat;

assign ZCat[3:0] = {A[2], B[3:2], RegFile[3]};

endmodule

A[2]

B[3]

B[2]

RegFile[3]

ZCat[3]

ZCat[2]

ZCat[1]

ZCat[0]



OPERADORES


selección de ‘bit’ variable en fuente

module SourceVariableSelection (Data, Index, Dout);input [0:3] Data;input [1:2] Index;output Dout;

assign Dout = Data[Index];

endmodule

Data[0]

Data[1]

Data[2]

Data[3]

00

01

10

11

Dout

Index[0]Index[1]



OPERADORES


selección de ‘bit’ variable en destino(no soportado por ISE)

module TargetVariable Selection (Mem, Store, Addr);input Store;input [1:3] Addr;output [7:0] Mem;

assign Mem[Addr] = Store;

endmodule

Mem[0]

Mem[1]

Mem[2]

Mem[3]

Mem[4]

Mem[5]

Mem[6]

Mem[7]

000

001

010

011

100

101

110

111

Store

Addr[0]Addr[1]Addr[2]



OPERADORES

Expresión condicional

<condición> ? <expresión 1> : <expresión 2>

module ConditionalExpression (StartXM, ShiftVal, Reset, StopXM);input StartXM, ShiftVal, Reset;output StopXM;

assign StopXM = (! Reset) ? StartXM ^ ShiftVal : StartXM | ShiftVal;

endmodule

1

0

StartXM

ShiftVal

Reset

StopXM



COMPORTAMIENTO COMBINACIONAL

descripción de comportamientocódigo secuencial

Sentencia ‘always’

module EvenParity (A, B, C, D, Z);input A, B, C, D;output Z;reg Z, Temp1, Temp2;

always @ (A or B or C or D)begin

Temp1 = A ^ B;Temp2 = C ^ D;Z = Temp1 ^ Temp2;

end

endmodule

ZABCD



lista de sensibilidadlógica combinacional

Sentencia ‘always’

module EvenParity (A, B, C, D, Z);input A, B, C, D;output Z;reg Z;

always @ (A or B)begin

Z = A ^ B ^ C ^ D;end

endmodule

ZABCD




Condición


module Condition (StartXM, ShiftVal, Reset, StopXM);input StartXM, ShiftVal, Reset;output StopXM;reg StopXM;

always @ (StartXM or ShiftVal or Reset)begin

if (Reset)StopXM = StartXM | ShiftVal;

elseStopXM = StartXM ^ ShiftVal;

end

endmodule

1

0

StartXM

ShiftVal

Reset

StopXM



Selección


module ALU (Op, A, B, Z);input [1:2] Op;input [0:1] A, B;output [0:1] Z;reg [0:1] Z;parameter ADD = 'b00,

SUB = 'b01,MUL = 'b10,AND = 'b11;

always @ (Op or A or B)begin

case (Op)ADD: Z = A + B;SUB: Z = A - B;MUL: Z = A * B;DIV: Z = A / B;

endcase

endmodule

A

Z

B

+/-

*

Op[1]Op[2]

00

01

10

11



Selección


module CaseExample (DayOfWeek, SleepTime);input [1:3] DayOfWeek;output [1:4] SleepTime;reg [1:4] SleepTime;parameter MON = 0, TUE = 1, WED = 2, THU = 3, FRI = 4, SAT = 5, SUN = 6;

always @ (DayOfWeek)begin

case (DayOfWeek)MON,TUE,WED,THU: SleepTime = 6;FRI : SleepTime = 8;SAT : SleepTime = 9;SUN : SleepTime = 7;default SlepTime = 10;

endcaseend

endmodule

000

001

010

011

100

101

110

111

DayOfWeek[1]DayOfWeek[2]DayOfWeek[3]

SleepTime[1]

SleepTime[2]

SleepTime[3]

SleepTime[4]



Selección con ‘z’ como ‘don´t care’


module CasezExample (ProgramCounter, DoCommand);input [0:3] ProgramCounter;output [0:1] DoCommand;reg [0:1] DoCommand;

always @ (ProgramCounter)begin

casez (ProgramCounter)4’bzzz1: DoCommand = 0;4’bzz10: DoCommand = 1;4’bz100: DoCommand = 2;4’b1000: DoCommand = 3;default DoCommand = 0;

endcaseend

endmodule

ProgramCounter[0]ProgramCounter[1]ProgramCounter[2]ProgramCounter[3]

DoCommand[0]

DoCommand[1]



Selección con ‘z’ y ‘x’ como ‘don´t care’


module CasexExample (ProgramCounter, DoCommand);input [0:3] ProgramCounter;output [0:1] DoCommand;reg [0:1] DoCommand;


casex (ProgramCounter)4’bxxx1: DoCommand = 0;4’bzz10: DoCommand = 1;4’bz100: DoCommand = 2;4’b1000: DoCommand = 3;default DoCommand = 0;

endcaseend

endmodule

ProgramCounter[0]ProgramCounter[1]ProgramCounter[2]ProgramCounter[3]

DoCommand[0]

DoCommand[1]



Orden de selección


codificador de prioridad



casex (ProgramCounter)4’bxxx1: DoCommand = 0;4’bxx1x: DoCommand = 1;4’bx1xx: DoCommand = 2;4’b1xxx: DoCommand = 3;default DoCommand = 0;

endcaseend

endmoduleProgramCounter[0]

ProgramCounter[1]

DoCommand[0]

DoCommand[1]

ProgramCounter[2]

ProgramCounter[3]



Orden de selección


codificador de prioridad



if (ProgramCounter[3])DoCommand = 0;

else if (ProgramCounter[2])DoCommand = 1;



else DoCommand = 0;end

endmodule

ProgramCounter[0]

ProgramCounter[1]

DoCommand[0]

DoCommand[1]

ProgramCounter[2]

ProgramCounter[3]



Lazos


‘while’‘forever’‘repeat’

‘for’

no soportada en síntesis





Lazos


‘for’

module DeMultiplexer (Address, Data, Line);input [1:0] Address;input Data;output [3:0] Line;reg [3:0] Line;

integer J;

always @ (Address)for (J = 3; J >= 0; J = J – 1)

if (Address == J)Line[J] = Data;

elseLine[J] = 0;

endmodule

Address[1]Address[0] Line[3]

Line[2]

Line[1]

Line[0]Data



Lazos


‘for’

module DeMultiplexer (Address, Line);input [1:0] Address;output [3:0] Line;reg [3:0] Line;

integer J;

always @ (Address)if (Address == 3) Line[J] = Data; else Line[J] = 0;if (Address == 3) Line[J] = Data; else Line[J] = 0;if (Address == 3) Line[J] = Data; else Line[J] = 0;if (Address == 3) Line[J] = Data; else Line[J] = 0;

endmodule

Address[1]Address[0] Line[3]

Line[2]

Line[1]

Line[0]Data



Condición

LÓGICA COMBINACIONAL

toda señal o variable o es asignada bajo cualquier condición de ejecución del proceso, o es utilizada después de ser asignada

module NonCombinationalLogic (A, B, C, Z);input A, B, C;output Z;reg Z;

always @ (A or B or C)begin: VAR_LABEL

reg D;

if (! A)Z = D;

elsebeginD = B & C;Z = 1;end

endendmodule

module NonCombinationalLogic (A, B, C, Z);input A, B, C;output Z;reg Z;


reg D;

D = B & C;if (! A)

Z = D;end

endmodule




module DeMultiplexer (Address, Data, Line);input [1:0] Address;input Data;output [3:0] Line;reg [3:0] Line;

integer J;

always @ (Address)for (J = 3; J >= 0; J = J – 1)

if (Address == J)Line[J] = Data;

endmodule

Condición




Condición



module CombinationalLogic (A, B, C, Z);input A, B, C;output Z;reg Z;


reg D;

if (! A)Z = 1;

elsebeginD = B & C;Z = D;end

endendmodule

B

C

A

Z



Condición



module CombinationalLogic (A, B, C);input A, B, C;output Z;reg Z;


reg D;

D = B & C;if (! A)

Z = D;else

Z = 1;end

endmodule

B

C

A

Z



Tareas


encapsulado de lógica combinacional

module FunctionCall (XBC, DataIn);input [0:5] DataIn;output [0:2] XBC;reg [0:2] XBCTemp;

task CountOnes;input [0:5] A;output [0:2] B;integer K;begin

B = 0;for (K = 0; K <= 5; K = K+1)

if (A[K])B = B + 1;

end;endtask

always @ (DataIn)CountOnes(DataIn, XBCTemp);

assign XBC = XBCTemp;

endmodule+

+

+

DataIn[0]

DataIn[1]

DataIn[2]

DataIn[3]

DataIn[4]

DataIn[5]

XBC

Transpar Tema1a

Technology