敏捷硬件开发语言Chisel与数字系统设计 课件 第3章 模块与硬件类型

3.模块与硬件类型西安交通大學XI'ANJIAOTONGUNIVERSITY目

录一、硬件类型二、赋值三、端口四、模块五、线网六、寄存器(组)七、补充与总结2一、硬件类型万安文通大学xIAN|IA(I(N

。1:NIVERSIIY3Chisel的数据类型是无法独立工作的，实际的电路应该是由硬件类型的对象构成的硬件类型完成：信号的声明、用赋值进行信号传递val

x=Wire(UInt(4.W)

)数据类型对象作为参数定义：位宽是多少、按无符号数还是有符号数解释、是不是向量val

x=Wire(UInt(4.W)

)硬件类型4二、赋值

安文通。1:NI大VFRSI学IY|1A(IN5首次创建变量时用赋值运算符“=”

初

始化驱动该端口时，就需要通过变量名来进行赋值操作，使用方法“:=”作为赋值运算符“=”的代替“:=”优先级与“=”一致，是最低的x:=

"b1010".UI1向4bit的线网x赋予了无符号数

10//把x按位取反，传递给yval

x=Wire(UInt(

4.W))val

y=Wire(UInt(4.W))赋值6三、端口

安文通。1:NI大VFRSI学IY|1A(IN73.1定义端口列表>端口列表是由方法“IO[T<:Data](iodef:T)

”定义>参数通常是一个Bundle

类型的对象>而且引用的字段名称必须是“io”

(继承自Module

的模块)端

口8>端口存在方向，需要方法“Input[T<:Data](source:T)

”和“Output[T<:Data](source:T)

”来为每个端口表明具体方向

>通过“io.xxx”来使用端口>从性质上来说它仍然属于组合逻辑的线网class

MylO

extends

Bundle{val

in=Input(Vec(

5

,

UInt(32.W)))val

out

=Output(UInt(

32.W))class

MyModule

extends

Module{val

io=IO(

newMyIO)II

模块的端口列表端

口3.2端口方向93.3翻转端口列表的方向使用情况：对于两个相连的模块，可能存在大量同名但方向相反的端口方法

：Flipped[T<:Data](source:T)实现细节其把参数里所有的输入端口转为输出端口，输出端口转为输入端口10端

口class

MylO

extends

Bundle{val

in=Input(Vec(5

,

UInt(32.W))val

out

=Output(UInt(

32.W))class

MyModule_1

extends

Module{

val

io=IO(

new

MyIO)//in是输入，

out是输出class

MyModule_2

extends

Module{

val

io=10(Flipped(

new

MyIO))//in

是输出，out

是输入inoutMyModule_1inoutMyModule_2端

口11>使用整体连接符号“<>”>该操作符会把符号左右两边的端口列表里所有同名的端口进行连接同一级的模块的端口方向必须是输入连

输出、输出连输入；父级模块和子级模块

的端口方向则是输入连输入、输出连输出

>不能存在端口名字、数量、类型不同的

情况classMylOextendsBundle{valin=Input(Vec(5,

UInt(32.W)))

valout

=Output(UInt(32.W))class

MyModuleextends

Module{valio

=IO(new

Bundle

{valx=

new

MylOval

y=Flipped(

new

MyIO)io.x

<>

io.yI11

相当于

io.y.in:=io.x.in;l/io.x.out

:=io.y.out端

口3.4端口整体连接12四、模块万安文通大学xIAN

|1A(IN

。1:NIVFRSIIY13Module/LegacyModule必须实现抽象成员io有隐式时钟(称为clock)

和隐式复位(称为reset)3

RawModule根据需要定义IO无抽象成员io不提供隐式时钟和复位4.1模块的分类Chisel的模块分为三类，继承关系如下(箭头指向父类)2

MultiIOModule根据需要定义IO无抽象成员io有隐式时钟和复位模块14继承自Module类包含一个用于接口的抽象字段

“io”

在类的主构造器里进行内部电路连线"new

Bundle{…}"

是声明一个继承自Bundle的匿名类，然后

实例化该匿名类。4.2定义模块定义一个二选一多路选择器：I/mux2.scalapackage

testimport

chisel3.classMux2

extends

Module{vali

o=T0(

new

Bundle{val

se7=7npui(UInt(1.

W)val

inO=Input(UInt(

1.W))val

in1

=Input(UInt(

1.W))

val

out

=Output(UInt(

1.W)模块io.out:=(io.se/&io.in7)|(~io.se/&io.ino)15valm0

=Module(newMux2)m0.io.sel:=io.se/(O)m0.io.in0:=io.in0m0.io.in1:=

io.in1val

m1=Module(new

Mux2)

m1.io.sel:=io.se/(O)m1.io.in0:=

io.in2m1.io.in1:=

io.in3val

m2=Module(

new

Mux2)

m2.io.sel:=io.se/(1)m2.io.in0

:=m0.io.outm2.io.in1:=m1.io.outio.out:=m2.io.outI/mux4.scalapackagetestimport

chisel3.class

Mux4

extends

Module{valio=IO(

new

Bundle{

val

in0=Input(UInt(1.W))val

in1=Input(UInt(1.W))val

in2=Input(UInt(1.W))valin3=Input(UInt(1.W))

val

sel=Input(UInt(

2.W)val

out=Output(UInt(1

.W))例化一个模块，要把实例对象传递给单例对象Module

的apply

方法通过例化刚才的双输入多路选择器构建四输入多路选择器：模块4.3例化模块164.4例化多个模块对于要多次例化的重复模块，可以利用向量的工厂方法VecInit[T<:Data]通常使用待例化模块的io字段组成的序列作为参数：//mux4_2.scalapackagetestimport

chisel3.class

Mux4_2

extends

Module{val

io

=IO(

new

Bundle

{val

inO=Input(UInt(1.W))val

in1=Input(UInt(1.W))val

in2=Input(UInt(1.W))val

in3=Input(UInt(1.W))val

se/=Input(UInt(

2.W))val

out=Output(UInt(

1

.W))模块17val

m=Veclnit(Seq.fill(3)(Module(new

Mux2).io))II

例化了三个Mux2,并且参数是端口字段iom(O).sel:=io.se/(0)//

模块的端口通过下标索引，并且路径里没有“io”m(O).in0

:=

io.inom(O).in1

:=io.in1m(1).sel:=io.se/(O)m(1).in0

:=

io.in2m(1).in1

:=io.in3m(2).sel:=io.sel(1

)m(2).in0

:=m(O).outm(2).in1

:=m(1).outio.out:=m(2).out·

生成序列的方法：调用单例对象Seq

里的方法fill,该方法的一个重载版本有两个单参数列表，第一个参数接收Int

类型的对象，表示序列的元素个数，第二个是传名参数，接收序列的元素。

18模块五、线网万安文通大学xIAN

|1A(IN

。1:NIVFRSIIY195.1Wire通过工厂方法“Wire[T<:Data](t:T)”来定义线网可以对线网进行赋值，也可以把线网连接到其他电路节点，线网是组成组合逻辑的基本硬件类型。class

MyModule

extendsModule{val

io=

IO(new

Bundle{val

in=Input(UInt(8.W))val

myNode

=Wire(UInt(

8.W))

myNode:=

0.

U;77无效myNode:=io.in

+1.U

----定义具有覆盖性，对同一

个线网多次赋值，则只有

最后一次赋值是有效的线网20不提供位宽参数将启用自动推断。官方源代码注释：val

w0

=Wire(UInt()//widthisinferredval

w1=Wire(UInt(

8.W)

//width

is

set

to

8val

w2

=Wire(Vec(

4,

UInt())

//widthisinferredval

w3=Wire(Vec(4,UInt(8.W))//width

of

each

elementis

set

to

8class

MyBundle{val

unknown=UInt()val

known=UInt(8.W)val

w4=Wire(

new

MyBundle)//Width

of

w4.unknown

is

inferred//Width

ofw4.known

is

set

to

8Wire21>WireDefault

用于构建具有默认连接的硬件线路有单参数和多参数两种形式。>

单参数使用参数来指定类型和默认连接：·对于non-literalchisel3.Bits,

导线的宽度将被推断。例1:Non-Literal

Element

initializer-width

willbeinferredvalx

=Wire(UInt())val

y=Wire(UInt(8.W))val

w1

=WireDefault(x)//width

willbeinferredval

w2=WireDefaulf(y)

//widthwillbeinferredWireDefault5.2WireDefault22例3:Aggregateinitializer:widthwillbesettomatchtheaggregateclass

MyBundle{val

unknown=UInt()valknown

=UInt(

8.W)val

w1=Wire(

newMyBundle)val

w2

=WireDefault(

w1)//Width

of

w2.unknown

is

inferred//Width

ofw2.known

is

set

to

8·对

于literal

chisel3.Bits和所有非Bits参数，类型将从参数复制。例2:Literalchisel3.Bitsinitializer:widthwillbesettomatchval

w1=WireDefaul(

1.U)//width

will

be

inferred

to

be

1

val

w2=WireDefaul(

1.U(8.W))//width

is

set

to

8WireDefault23双参数形式允许独立指定Wire的类型和默认连接。带有两个参数的WireDefault

的宽度推断语义与Wire

的相匹配。

WireDefault的第一个参数是类型模板，它定义了Wire

的宽度，其方式与Wire

的参数完全

相

同

。其定义类似于：def

WireDefault[T<:Data](t:

T,init:T):T={val

x=Wire(t)X:=initwire

[7:0]a;wire

[9:0]b={{2'd0},a};

24val

a

=Wire(UInt(

8.W))val

b=WireDefaulf(UInt(

10.W),a)WireDefault六、寄存器(组)万安文通大学xIAN

|1A(IN

。1:NIVFRSIIY25Chisel有五种内建的寄存器，

Reg、RegNext、RegInit、util

包里的RegEnable

和ShiftRegister6.1

Reg普通的寄存器“Reg[T<:Data](t:T):T

”可以在when

语句里用全局reset

信号进行同步复位(asBool),

也

可

以进行条件赋值或无条件跟随入参必须是数据类型的对象寄存器26和Wire

的构造方式非常类似val

rO=Reg(UInt()

//width

is

inferredval

r1=Reg(UInt(

8.W))I/width

is

set

to

8val

r2

=Reg(Vec(

4,

UInt())//width

is

inferredval

r3=Reg(Vec(

4,UInt(

8.W)))I/width

of

each

element

is

set

to

8class

MyBundle

{val

unknown

=Ulnt()val

known

=UInt(

8.W)val

r4

=Reg(

new

MyBundle)I/Widthof

r4.unknown

is

inferred//Widthof

r4.known

is

set

to

8寄存器27val

foo=Reg(UInt(4.W))//width

is

4val

bar

=RegNext(

foo)//widthisunsetval

foo=Reg(UInt(4.W))

//widthis

4

val

bar=Reg(chiselTypeOf

foo))//width

is

4bar:=

fooclass

MyBundle

extends

Bundle

{

val

x=UInt(

4.W)val

foo=Wire(

new

MyBundle)//thewidth

of

foo.x

is

4val

bar

=RegNext(

foo)//the

width

of

bar.x

is

4“

RegNext[T<:Data](next:T)

”,没有复位信号另

一

个版本的apply

工厂方法是“RegNext[T<:Data](next:T,init:T)”,是由复位信号控制RegNext

经常用于构造延迟一个周期的信号。寄存器6.2

RegNext28复位到指定值的寄存器RegInit,

也有两种构造方式：“

RegInit[T<:Data](init:T)”"RegInit[T<:Data](t:T,init:T)"单参数形式使用参数来指定类型和重置值·对于non-literal

chisel3.Bits、Reg的宽度将被推断例1:Non-Literal

Element

initializer-width

willbeinferredvalx

=Wire(UInt())valy=Wire(UInt(

8.W))val

r1=Reglnit(x)//widthwill

be

inferredvalr2=Reglni(

y)//width

willbeinferred寄存器6.3

RegInit29例

3:Aggregate

initializer:widthwillbe

set

to

match

the

aggregateclass

MyBundleextends

Bundle{val

unknown

=UInt()val

known

=UInt(8.W)val

w1

=Reg(

newMyBundle)val

w2=Reglnit(

w1)//Width

ofw2.unknown

is

inferred//Width

ofw2.known

is

set

to

8·对

于literal

chisel3.Bits和所有非Bits

参数，类型将从参数复制。例2:Literalchisel3.Bitsinitializer:widthwillbesetto

matchval

r1=Reglni(

1.U)//width

will

be

inferred

to

be

1val

r2=Reglnit(1.U(

8.W)

//width

is

set

to

8寄存器30双参数形式允许独立指定Reg

的类型和默认连接。带有两个参数的RegInit的宽度推断语义与Reg

的宽度推断语义相匹配。RegInit的第一个参数是类型模板，它定义Reg

的宽度的方式与Wire的完全相

同。其定义类似于：def

Reglnit

[T<:Data](t:

T,

init:T):T={val

x=Reg(t)x:=init寄存器31object

RegEnable{def

apply[T<:Data](next:T,

enable:Bool):

T=val

r=Reg(chise/TypeOfnext))

when(enable){r:=next}def

apply[T<:Data](next:T,init:

T,

enable:Bool):T=val

r=Reglnit(init)when(enable){r:=next}第二个apply

方法，进行复位初始化。例：第一个apply

方法，不进行复位初始化。例：val

regWithEnableAndReset=RegEnable(nextVal,0.U,ena)val

regWithEnableAndReset=RegEnable(nextVal,ena)寄存器6.4

RegEnable32第一个参数in是待移位的数据，第二个参数n是需要延迟的周期数，

第三个参数resetData是指定的复位值，可以省略，第四个参数en

是移位的使能信号，

默认为true.B,也是通过两个apply方法实现的val

regDelayTwoReset=ShitRegister(nextVal,

2,0.

U,ena)val

regDelayTwo

=ShiftRegister(nextVal,2,ena)寄存器"

ShiftRegister[T<:Data](in:T,n:Int,resetData:T,en:Bool)"6.5ShiftRegister336.6异步寄存器使

用withClockAndReset

来构造异步时钟和异步复位信号，也可以用withClock

和withReset

单独控制异步时钟或异步复位信号classasyncReg

extends

Module{valio=IO(new

Bundle{val

asyncClk

=Input(Ulnt(1.W))val

asyncRst=Input(UInt(

1.W))val

out

=Output(UInt(

8.W))val

asyncReglnit=withClockAndReset(io.asyncClk.asBool().asClock(),

io.asyncRst.asBool().asAsyncReset())(Reglnit(O.U(8.W))asyncReglnit:=asyncReglnit

+1.Uio.out:=

asyncReglnit寄存器34val

regO=RegNex((Veclnit(

io.a,io.a))valreg1=RegNext(Veclnit(

io.a,io.a),Veclnit(0.U,0.U))val

reg2

=Reglnit(Veclnit

(O.U(8.W),0.U(8.W))val

reg3=Reg(Vec(

2,

UInt(8.W))val

reg4=Reg(Vec(

2,UInt(8.W)))val

reg5=RegEnable(Veclnit

io.a+1.U,io.a+1.U),Veclnit(O.U(8.W),0.U(8.W)),io.en)val

reg6

=RegEnable(Veclnit

io.a-1.U,io.a-1.U),io.en)如果把子类型Vec[T]作为参数传递进去，就会生成多个位宽相同、行为相同、名字前缀相同的寄存器。同样，寄存器组在Chisel代码里可以通过下标索引。寄存器6.7寄存器组35val

reg7=ShiftRegister(Veclnit(io.a,io.a),3,Veclnit(O.U(8.W),0.U(8.W)),io.en)val

reg8=ShiftRegister(Veclnit

io.a,io.a),

3,io.en)reg2(0):=io.a.andRreg2(1):=

io.a

andRreg3(0):=

io.a.orRreg3(1):=io.a.orRwhen(

reset.asBool){reg4(0):=

0.Ureg4(1):=

0.U}.otherwise{reg4(0):=

1.Ureg4(1):=

1.U寄存器36七、补充与总结万安文通大学xIAN

|1A(IN

。1:NIVFRSIIY377.1

when条件赋值由于Scala已经占用了“if…else

if..else”语法，所以相应的Chisel控制

结构改成了when语句，其语法如下：when(condition1){definition1}.elsewhen(condition2){definition

2}.elsewhen(condition

N){definition

N}.otherwise{default

behavior}所有的判断条件都

是返

回Bool类

型的传名参数，不要和Scala的Boolean

类型混淆，也不存在Boolean

和Bool之间的相互转换。对于UInt、SInt

和Reset类型，可以用方法asBool转换成Bool

类型来作为判断条件。补充与总结38//mux2_when.scalapackagetestimport

chisel3.class

Mux2

extendsModule{val

io=IO(

new

Bundle{val

se/

=Input(UInt(

1.W))val

inO=Input(UInt(

1.W))val

in1=Input(UInt(1.W))

val

out=Output(UInt(

1.W))when(

io.se/

===

1.U){io.out:=io.in1}.otherwise{io.out:=io.ino通常，when用于给带使能信号的寄存器更新数据，组合逻辑不常用。对于有复位信号的寄存器，推荐使用RegInit来声明补充与总结用when

实现一个二选一多路选择器：39除

了when结

构

，util

包里还有一个与之对偶的结构“unless”,如果unless的判定条件为false.B,则一直执行，否则不执行import

chisel3.util.unless(condition){definition}unless7.2

unless40valreg0=RegNex(Veclnit

io.a,io.a)//正

确valreg0=RegNext(Vec

(2,io.a))

11错误，报错如下//[error]chisel3.core.Binding$ExpectedChiselTypeException:vec

type'chisel