Chisel中的寄存器操作

Chisel中的寄存器操作

• 寄存器的分类以及仿真结果

寄存器的分类以及仿真结果

跟随寄存器

RegNext[T<:Data](next:T)
示例如下

class REG extends Module{
val io = IO(new Bundle {
    val a = Input(UInt(8.W))
    val en = Input(Bool())
    val c = Output(UInt(1.W))
  })
val reg0 =RegNext(io.a)//每个上升沿采样一个传入的参数
val reg1=RegNext(io.a,0.U)//需要复位信号控制，复位信号有效时，复位到指定值，否则就跟随
}

转换出的语言

always @(posedge clock) begin
    reg0 <= io_a;
    if (reset) begin
      reg1 <= 8'h0;
    end else begin
      reg1 <= io_a;
    end
 end

复位到指定值的寄存器

RegInit[T <: Data](init: T)
代码使用如下
需要声明位宽，否则为默认位宽，可以用when语句进行赋值

class REG extends Module{
val io = IO(new Bundle {
    val a = Input(UInt(8.W))
    val en = Input(Bool())
    val c = Output(UInt(1.W))
  })
val reg2 =RegInit(0.U(8.W))//reset则复位到指定值，可以用when来控制赋值

reg2:=io.a.andR//所有位采取和操作
}

生成代码如下

assign _T_9 = ~ io_a; 
assign _T_10 = _T_9 == 8'h0; 

always @(posedge clock) begin
    
    if (reset) begin
      reg2 <= 8'h0;
    end else begin
      reg1 <= {{7'd0}, _T_10};
    end
end

普通寄存器

Reg[T <: Data](t: T)

可以在when语句里用全局reset信号进行同步复位(reset信号是Reset类型，要用toBool进行类型转换)，也可以进行条件赋值或无条件跟随。参数同样要指定位宽。

class REG extends Module{
val io = IO(new Bundle {
    val a = Input(UInt(8.W))
    val en = Input(Bool())
    val c = Output(UInt(1.W))
  })
val reg3 =Reg(Uinit(8.W))//reset则复位到指定值，可以用when来控制赋值
val reg4 = Reg(UInt(8.W))

reg3:=io.a.orR//所有位采取和操作
when(reset.toBool) {
    reg4 := 0.U
  } .otherwise {
    reg4 := 1.U
}

assign _T_11 = io_a != 8'h0; 
assign _GEN_8 = reset ? 1'h0 : 1'h1;

always @(posedge clock) begin
    reg3 <= {{7'd0}, _T_11};
    reg4 <= {{7'd0}, _GEN_8}; 
end

使能寄存器

util包里的带一个使能端的寄存器“RegEnable[T <: Data](next: T, init: T, enable: Bool)”，如果不需要复位信号，则第二个参数可以省略给出。

class REG extends Module{
val io = IO(new Bundle {
    val a = Input(UInt(8.W))
    val en = Input(Bool())
    val c = Output(UInt(1.W))
  })
val reg5 = RegEnable(io.a + 1.U, 0.U, io.en)
val reg6 = RegEnable(io.a - 1.U, io.en)



}

assign _T_1 = io_a + 8'h1;
assign _T_2 = io_a - 8'h1; 
assign _T_3 = $unsigned(_T_2); 
assign _T_4 = _T_3[7:0];


always @(posedge clock) begin
   if (reset) begin
      reg5 <= 8'h0;
    end else begin
      if (io_en) begin
        reg5 <= _T_1;
      end
    end
    if (io_en) begin
      reg6 <= _T_4;
    end
end

移位寄存器

util包里的移位寄存器“ShiftRegister[T <: Data](in: T, n: Int, resetData: T, en: Bool)”，其中第一个参数in是带移位的数据，第二个参数n是需要延迟的周期数，第三个参数resetData是指定的复位值，可以省略，第四个参数en是使能移位的信号，默认为true.B。

class REG extends Module{
val io = IO(new Bundle {
    val a = Input(UInt(8.W))
    val en = Input(Bool())
    val c = Output(UInt(1.W))
  })
  
val reg7 = ShiftRegister(io.a, 3, 0.U, io.en)
val reg8 = ShiftRegister(io.a, 3, io.en)

}

always @(posedge clock) begin
  if (reset) begin
      _T_5 <= 8'h0;
    end else begin
      if (io_en) begin
        _T_5 <= io_a;
      end
    end
    if (reset) begin
      _T_6 <= 8'h0;
    end else begin
      if (io_en) begin
        _T_6 <= _T_5;
      end
    end
    if (reset) begin
      reg7 <= 8'h0;
    end else begin
      if (io_en) begin
        reg7 <= _T_6;
      end
    end
	if (io_en) begin
	      _T_7 <= io_a;
	    end
	    if (io_en) begin
	      _T_8 <= _T_7;
	    end
	    if (io_en) begin
	      reg8 <= _T_8;
	    end
end