chisel编码初体验

本文记录了初次使用chisel编码时遇到的一些问题及解决办法，希望对以后的工作有所帮助。

1、内部信号赋值

1.1 单bit数信号定义

    单bit使能需要定义为Bool型，在io端口定义如下

val pipe_en = Input(Bool())

 

注意："Bool"后需要加"()"

1.2 寄存器打拍

    Chisel中支持的Reg类型有RegNext、RegInit、RegEnable、ShiftRegister，具体的差别和使用方法可参考Chisel中的几种常见的寄存器_CrazyUncle的博客-CSDN博客

    我们在编码时常需要对信号打拍的操作，可以用到的语句有RegNext和ShiftRegister，两者的使用方法:

RegNext是跟随寄存器，每个时钟的上升沿，都会采样一次传入的参数。

示例：

无复位： val reg0 = RegNext(io.a)

有复位： val reg1 = RegNext(io.a,0.U)

ShiftRegister是移位寄存器，第一个参数是待移位数据；第二个参数是需要延迟的周期数；第三个参数是指定的复位值，可以省略；第四个参数是移位的使能信号，默认值是1。

示例：

val reg2 = ShiftRegister（io.a,3,0.U,io.en）

表示reg2为在“io.en”为高时，对“io.a”打三拍之后的信号，复位后其值为0。

ShiftRegister可以代替RegNext，只需要将ShiftRegister的第二个参数改为1

RegNext只能打1拍，ShiftRegister可以打n拍，并可以加入打拍的使能信号

笔者在使用的过程中感到ShiftRegister比RegNext好用很多，甚至可以完全代替RegNext。因为RegNext只能打1拍，ShiftRegister可以打n拍，并可以加入打拍的使能信号。只需要将ShiftRegister的第二个参数改为1，就可以替代RegNext的功能。

1.3 数据字面量

可以通过BigInt、Int、Long和String四种类型的Scala字面量来构造UInt和SInt。按Scala的语法，其中BigInt、Int、Long三种类型默认是十进制的，但可以加前缀“0x”或“0X”变成十六进制。对于字符串类型的字面量，Chisel编译器默认也是十进制的，但是可以加上首字母“h”、“o”、“b”来分别表示十六进制、八进制和二进制。此外，字符串字面量可以用下划线间隔。

可以通过Boolean类型的字面量——true和false——来构造fromBooleanToLiteral类型的对象，然后调用名为B和asBool的方法进一步构造Bool类型的对象。例如：

1.U                // 字面值为“1”的UInt对象

-8.S               // 字面值为“-8”的SInt对象

"b0101".U     // 字面值为“5”的UInt对象

true.B            // 字面值为“true”的Bool对象 

1.4 二维数组使用示例

import chisel3._
import chisel3.experimental.RawModule
 
class Hello extends RawModule {
  val io = IO(new Bundle {
  })
  val v = Wire(Vec(3, UInt(4.W)))
  val a = Wire(UInt(4.W))
 
  val idx = 1.U(2.W)
  v(0) := 1.U
  v(1) := 3.U
  v(2) := 5.U
 
  a := v(idx)
 
}
 
object TesterApp extends App {
    chisel3.Driver.execute(Array("-td", "chisel"), () => new Hello())
}

转verilog：

module Hello( //@[chiseltest.scala 4:21]
 
);
 
wire [3:0] v[2:0]; //@[chiseltest.scala 7:15]
 
wire [3:0] a; //@[chiseltest.scala 8:15]
 
assign v[0] = 4'h1; //@[chiseltest.scala 10:8]
 
assign v[1] = 4'h3; //@[chiseltest.scala 11:8]
 
assign v[2] = 4'h5; //@[chiseltest.scala 12:8]
 
assign a = v[1]; //@[chiseltest.scala 13:5]
 
endmodule

1.5 模块例化

// mux4.scala
package test
 
import chisel3._
class Mux4 extends Module {
  val io = IO(new Bundle {
    val in0 = Input(UInt(1.W))
    val in1 = Input(UInt(1.W))
    val in2 = Input(UInt(1.W))
    val in3 = Input(UInt(1.W))
    val sel = Input(UInt(2.W))
    val out = Output(UInt(1.W))
  })
  val m0 = Module(new Mux2)
  m0.io.sel := io.sel(0)
  m0.io.in0 := io.in0
  m0.io.in1 := io.in1
  val m1 = Module(new Mux2)
  m1.io.sel := io.sel(0)
  m1.io.in0 := io.in2
  m1.io.in1 := io.in3
  val m2 = Module(new Mux2)
  m2.io.sel := io.sel(1)
  m2.io.in0 := m0.io.out
  m2.io.in1 := m1.io.out
  io.out := m2.io.out

重复多次例化某模块

// mux4_2.scala
package test
 
import chisel3._
class Mux4_2 extends Module {
  val io = IO(new Bundle {
    val in0 = Input(UInt(1.W))
    val in1 = Input(UInt(1.W))
    val in2 = Input(UInt(1.W))
    val in3 = Input(UInt(1.W))
    val sel = Input(UInt(2.W))
    val out = Output(UInt(1.W))
  })
  val m = VecInit(Seq.fill(3)(Module(new Mux2).io))  // 例化了三个Mux2，并且参数是端口字段io
  m(0).sel := io.sel(0)  // 模块的端口通过下标索引，并且路径里没有“io”
  m(0).in0 := io.in0
  m(0).in1 := io.in1
  m(1).sel := io.sel(0)
  m(1).in0 := io.in2
  m(1).in1 := io.in3
  m(2).sel := io.sel(1)
  m(2).in0 := m(0).out
  m(2).in1 := m(1).out
  io.out := m(2).out
}

1.6 二维数组使用示例

import chisel3._
import chisel3.experimental.RawModule
class Hello extends RawModule {
  val io = IO(new Bundle {
  })
  val v = Wire(Vec(3, UInt(4.W)))
  val a = Wire(UInt(4.W))
  val idx = 1.U(2.W)
  v(0) := 1.U
  v(1) := 3.U
  v(2) := 5.U
  a := v(idx)
}

1.7 寄存器组

        当我们用寄存器写一个fifo的时候，往往会用到寄存器组，我们可以先看一下用chisel来实现它的定义和使用。

val fifo = RegInit(VecInit(Seq.fill(3)(0.U(dw.W))))
val waddr = RegInit(0.U(2.W))
when(io.vld) {waddr := waddr + 1.U}
when(io.vld) {
	fifo(3) := io.data
	switch(waddr){
		is(0.U) fifo(0) := io.data
		is(1.U) fifo(1) := io.data
		is(2.U) fifo(2) := io.data
	}
}

1)、定义

   Vec代表相同类型的信号的集合（矢量）。每个元素都可以由索引访问。Chisel Vec类似于其他编程语言中的数组数据结构。Vec是通过调用带有两个参数的构造函数来创建的：元素的数量和元素的类型（元素的类型也可以是Vec）。

wire型的使用见右侧，此处主要讨论reg型

15行为定义寄存器组

RegInit表示定义带复位的寄存器

Seq是将变量打包成数组

VecInit：接受一个Seq作为参数来构造向量。VecInit常把有字面值的数据作为参数，用于初始化寄存器组等操作。