CHISEL 点滴积累 之五

最新推荐文章于 2024-09-13 10:24:50 发布
原创 最新推荐文章于 2024-09-13 10:24:50 发布 · 582 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个使用Chisel硬件描述语言实现的简单有限状态机(FSM)，该状态机用于控制类似Knight Rider电视节目中汽车灯效果的LED。文章详细展示了如何在Chisel中设计FSM，包括慢速时钟生成、复位信号处理和LED闪烁控制。 
/*
 * Simple FSM example including slow frequency tick generation and
 * reset handling with a top level Chisel component.
 * 
 * This code is part of the Chisel examples.
 * 
 * Copyright: 2015, Technical University of Denmark, DTU Compute
 * Author: Martin Schoeberl (martin@jopdesign.com)
 * License: Simplified BSD License
 * 
 * A simple finite state machine (FSM) that drives LEDs like
 * on the lights on the Knight Rider car.
 * 
 */

package simple

import chisel3._
import chisel3.util._

/**
 * Do some fancy blinking.
  *
  * TODO: find out the new way to have a reset signal
 */
class KnightRider(resetSignal: Bool = null, frequ: Int)
 //调用的时候我们发现，这里参数也可以非常数
    extends Module(_reset = resetSignal) {
    // extends Module {
  val io = IO(new Bundle {
    val led = Output(Bits(6.W))
  })

  val goLeft :: goRight :: Nil = Enum(2)

  val stateReg = RegInit(goLeft) //寄存器初始化
  val ledReg = RegInit(1.U(6.W)) //定义6位寄存器，初始数值是1 

  val tick = Module(new Tick(frequ)) // frequ 初始化

  // Update FSM state and registers only with low frequency tick
  when(tick.io.tick === 1.U) {
    // State change one tick earlier
    when(ledReg(4) === 1.U) {
      stateReg := goRight
    }.elsewhen(ledReg(1) === 1.U) { //提前修改方向
      stateReg := goLeft
    }

    when(stateReg === goLeft) {
      ledReg := ledReg << 1  // 移位寄存器
    }.otherwise {
      ledReg := ledReg >> 1  // 移位寄存器
    }

  }

  io.led := ledReg   
}

/**
 * Generate a 6 Hz tick to drive the FSM.
 */
class Tick(frequ: Int) extends Module {
  val io = IO(new Bundle {
    val tick = Output(Bits(1.W))
  })
  val CNT_MAX = (frequ / 6 - 1).asUInt()

  val r1 = RegInit(0.U(32.W))  

  val limit = r1 === CNT_MAX  // 边界
  val tick = limit           // 边界作为 时钟滴答 

  r1 := r1 + 1.U
  when(limit) {
    r1 := 0.U
  }

  io.tick := tick
}

/**
 * This is a reset "generator". However, this works ONLY
 * in an FPGA when registers are reset to 0 on FPGA configuration.
 *
 * However, as we do not have a chance to specify register power up
 * attributes, this is a fragile solution (did not work for 2 or 3
 * bit wide counters).
 */
class ResetGen() extends Module {
  val io = IO(new Bundle {
    val resetOut = Output(Bool())
  })

  val cnt = Reg(UInt(4.W))  // 声明一个寄存器但是没有赋值

  when(cnt =/= 15.U) {
    cnt := cnt + 1.U
    io.resetOut := true.B //给Bool类型赋值的方法。
  }.otherwise {
    cnt := cnt // this should not be needed, but without it the gen. code is wrong
    io.resetOut := false.B // false.B
  }
}


/**
 * Top level to connect the button to the reset.
 */
class KnightTop extends Module {
  val io = IO(new Bundle {
    val btn = Input(UInt(4.W))
    val led = Output(Bits(6.W))
  })

  // Invert the reset button and two flip-flop input synchronization
  val manReset = (~io.btn(3)).toBool   //转换成Bool类型
  val syncBtn = RegNext(RegNext(manReset)) //RegNext是延迟一级寄存器的意思

  val resGen = Module(new ResetGen()) //生成一个复位模块

  // Manual or generated reset
  val resetVal = syncBtn || resGen.io.resetOut

  // DE2-115 has a 50 MHz clock
  val knight = Module(new KnightRider(resetVal, 50000000))
  // 调用的时候我们发现，这里参数也可以非常数,resetVal


  io.led <> knight.io.led //这里为什么不适用 := 来赋值
}

object KnightMain extends App {
  chisel3.Driver.execute(Array("--target-dir", "generated"), () => new KnightTop())
}

 

module ResetGen( // @[:@3.2]
  input   clock, // @[:@4.4]
  output  io_resetOut // @[:@6.4]
);
  reg [3:0] cnt; // @[KnightRider.scala 95:16:@8.4]
  reg [31:0] _RAND_0;
  wire  _T_9; // @[KnightRider.scala 97:12:@9.4]
  wire [4:0] _T_11; // @[KnightRider.scala 98:16:@11.6]
  wire [3:0] _T_12; // @[KnightRider.scala 98:16:@12.6]
  assign _T_9 = cnt != 4'hf; // @[KnightRider.scala 97:12:@9.4]
  assign _T_11 = cnt + 4'h1; // @[KnightRider.scala 98:16:@11.6]
  assign _T_12 = _T_11[3:0]; // @[KnightRider.scala 98:16:@12.6]
  assign io_resetOut = cnt != 4'hf; // @[KnightRider.scala 99:17:@14.6 KnightRider.scala 102:17:@18.6]
`ifdef RANDOMIZE_GARBAGE_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_INVALID_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_REG_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_MEM_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE
  integer initvar;
  initial begin
    `ifndef verilator
      #0.002 begin end
    `endif
  `ifdef RANDOMIZE_REG_INIT
  _RAND_0 = {1{$random}};
  cnt = _RAND_0[3:0];
  `endif // RANDOMIZE_REG_INIT
  end
`endif // RANDOMIZE
  always @(posedge clock) begin
    if (_T_9) begin
      cnt <= _T_12;
    end
  end
endmodule
module Tick( // @[:@21.2]
  input   clock, // @[:@22.4]
  input   reset, // @[:@23.4]
  output  io_tick // @[:@24.4]
);
  reg [31:0] r1; // @[KnightRider.scala 69:19:@26.4]
  reg [31:0] _RAND_0;
  wire  limit; // @[KnightRider.scala 71:18:@27.4]
  wire [32:0] _T_10; // @[KnightRider.scala 74:12:@28.4]
  wire [31:0] _T_11; // @[KnightRider.scala 74:12:@29.4]
  wire [31:0] _GEN_0; // @[KnightRider.scala 75:15:@31.4]
  assign limit = r1 == 32'h7f2814; // @[KnightRider.scala 71:18:@27.4]
  assign _T_10 = r1 + 32'h1; // @[KnightRider.scala 74:12:@28.4]
  assign _T_11 = _T_10[31:0]; // @[KnightRider.scala 74:12:@29.4]
  assign _GEN_0 = limit ? 32'h0 : _T_11; // @[KnightRider.scala 75:15:@31.4]
  assign io_tick = r1 == 32'h7f2814; // @[KnightRider.scala 79:11:@34.4]
`ifdef RANDOMIZE_GARBAGE_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_INVALID_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_REG_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_MEM_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE
  integer initvar;
  initial begin
    `ifndef verilator
      #0.002 begin end
    `endif
  `ifdef RANDOMIZE_REG_INIT
  _RAND_0 = {1{$random}};
  r1 = _RAND_0[31:0];
  `endif // RANDOMIZE_REG_INIT
  end
`endif // RANDOMIZE
  always @(posedge clock) begin
    if (reset) begin
      r1 <= 32'h0;
    end else begin
      if (limit) begin
        r1 <= 32'h0;
      end else begin
        r1 <= _T_11;
      end
    end
  end
endmodule
module KnightRider( // @[:@36.2]
  input        clock, // @[:@37.4]
  input        reset, // @[:@38.4]
  output [5:0] io_led // @[:@39.4]
);
  wire  tick_clock; // @[KnightRider.scala 38:20:@43.4]
  wire  tick_reset; // @[KnightRider.scala 38:20:@43.4]
  wire  tick_io_tick; // @[KnightRider.scala 38:20:@43.4]
  reg  stateReg; // @[KnightRider.scala 35:25:@41.4]
  reg [31:0] _RAND_0;
  reg [5:0] ledReg; // @[KnightRider.scala 36:23:@42.4]
  reg [31:0] _RAND_1;
  wire  _T_11; // @[KnightRider.scala 41:21:@46.4]
  wire  _T_12; // @[KnightRider.scala 44:16:@48.6]
  wire  _T_15; // @[KnightRider.scala 46:22:@54.8]
  wire  _GEN_0; // @[KnightRider.scala 46:35:@56.8]
  wire  _GEN_1; // @[KnightRider.scala 44:29:@50.6]
  wire  _T_18; // @[KnightRider.scala 50:19:@59.6]
  wire [6:0] _GEN_5; // @[KnightRider.scala 51:24:@61.8]
  wire [6:0] _T_19; // @[KnightRider.scala 51:24:@61.8]
  wire [4:0] _T_20; // @[KnightRider.scala 53:24:@65.8]
  wire [6:0] _GEN_2; // @[KnightRider.scala 50:31:@60.6]
  wire  _GEN_3; // @[KnightRider.scala 41:30:@47.4]
  wire [6:0] _GEN_4; // @[KnightRider.scala 41:30:@47.4]
  Tick tick ( // @[KnightRider.scala 38:20:@43.4]
    .clock(tick_clock),
    .reset(tick_reset),
    .io_tick(tick_io_tick)
  );
  assign _T_11 = tick_io_tick; // @[KnightRider.scala 41:21:@46.4]
  assign _T_12 = ledReg[4]; // @[KnightRider.scala 44:16:@48.6]
  assign _T_15 = ledReg[1]; // @[KnightRider.scala 46:22:@54.8]
  assign _GEN_0 = _T_15 ? 1'h0 : stateReg; // @[KnightRider.scala 46:35:@56.8]
  assign _GEN_1 = _T_12 ? 1'h1 : _GEN_0; // @[KnightRider.scala 44:29:@50.6]
  assign _T_18 = stateReg == 1'h0; // @[KnightRider.scala 50:19:@59.6]
  assign _GEN_5 = {{1'd0}, ledReg}; // @[KnightRider.scala 51:24:@61.8]
  assign _T_19 = _GEN_5 << 1; // @[KnightRider.scala 51:24:@61.8]
  assign _T_20 = ledReg[5:1]; // @[KnightRider.scala 53:24:@65.8]
  assign _GEN_2 = _T_18 ? _T_19 : {{2'd0}, _T_20}; // @[KnightRider.scala 50:31:@60.6]
  assign _GEN_3 = _T_11 ? _GEN_1 : stateReg; // @[KnightRider.scala 41:30:@47.4]
  assign _GEN_4 = _T_11 ? _GEN_2 : {{1'd0}, ledReg}; // @[KnightRider.scala 41:30:@47.4]
  assign io_led = ledReg; // @[KnightRider.scala 57:10:@69.4]
  assign tick_clock = clock; // @[:@44.4]
  assign tick_reset = reset; // @[:@45.4]
`ifdef RANDOMIZE_GARBAGE_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_INVALID_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_REG_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_MEM_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE
  integer initvar;
  initial begin
    `ifndef verilator
      #0.002 begin end
    `endif
  `ifdef RANDOMIZE_REG_INIT
  _RAND_0 = {1{$random}};
  stateReg = _RAND_0[0:0];
  `endif // RANDOMIZE_REG_INIT
  `ifdef RANDOMIZE_REG_INIT
  _RAND_1 = {1{$random}};
  ledReg = _RAND_1[5:0];
  `endif // RANDOMIZE_REG_INIT
  end
`endif // RANDOMIZE
  always @(posedge clock) begin
    if (reset) begin
      stateReg <= 1'h0;
    end else begin
      if (_T_11) begin
        if (_T_12) begin
          stateReg <= 1'h1;
        end else begin
          if (_T_15) begin
            stateReg <= 1'h0;
          end
        end
      end
    end
    if (reset) begin
      ledReg <= 6'h1;
    end else begin
      ledReg <= _GEN_4[5:0];
    end
  end
endmodule
module KnightTop( // @[:@71.2]
  input        clock, // @[:@72.4]
  input        reset, // @[:@73.4]
  input  [3:0] io_btn, // @[:@74.4]
  output [5:0] io_led // @[:@74.4]
);
  wire  resGen_clock; // @[KnightRider.scala 120:22:@83.4]
  wire  resGen_io_resetOut; // @[KnightRider.scala 120:22:@83.4]
  wire  knight_clock; // @[KnightRider.scala 126:22:@87.4]
  wire  knight_reset; // @[KnightRider.scala 126:22:@87.4]
  wire [5:0] knight_io_led; // @[KnightRider.scala 126:22:@87.4]
  wire  _T_9; // @[KnightRider.scala 117:26:@76.4]
  reg  _T_12; // @[KnightRider.scala 118:32:@79.4]
  reg [31:0] _RAND_0;
  reg  syncBtn; // @[KnightRider.scala 118:24:@81.4]
  reg [31:0] _RAND_1;
  ResetGen resGen ( // @[KnightRider.scala 120:22:@83.4]
    .clock(resGen_clock),
    .io_resetOut(resGen_io_resetOut)
  );
  KnightRider knight ( // @[KnightRider.scala 126:22:@87.4]
    .clock(knight_clock),
    .reset(knight_reset),
    .io_led(knight_io_led)
  );
  assign _T_9 = io_btn[3]; // @[KnightRider.scala 117:26:@76.4]
  assign io_led = knight_io_led; // @[KnightRider.scala 128:10:@90.4]
  assign resGen_clock = clock; // @[:@84.4]
  assign knight_clock = clock; // @[:@88.4]
  assign knight_reset = syncBtn | resGen_io_resetOut; // @[:@89.4]
`ifdef RANDOMIZE_GARBAGE_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_INVALID_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_REG_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_MEM_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE
  integer initvar;
  initial begin
    `ifndef verilator
      #0.002 begin end
    `endif
  `ifdef RANDOMIZE_REG_INIT
  _RAND_0 = {1{$random}};
  _T_12 = _RAND_0[0:0];
  `endif // RANDOMIZE_REG_INIT
  `ifdef RANDOMIZE_REG_INIT
  _RAND_1 = {1{$random}};
  syncBtn = _RAND_1[0:0];
  `endif // RANDOMIZE_REG_INIT
  end
`endif // RANDOMIZE
  always @(posedge clock) begin
    _T_12 <= ~ _T_9;
    syncBtn <= _T_12;
  end
endmodule

 

总结：

1，参数可以在调用的时候赋给变量数值，其实就相当于端口了，这是VERILOG中做不到的。

2，class KnightRider(resetSignal: Bool = null, frequ: Int) extends Module(_reset = resetSignal)

这里的_reset是指示复位信号是resetSignal这个参数

3，val goLeft :: goRight :: Nil = Enum(2)  这是定义了一个枚举类型。

 

 

 

 

 

 

 

 

 

 

 

 

Chisel入门------Chisel的基本语法3
qq_38798111的博客
03-11 1726
这部分将继续介绍状态机和一些高阶函数的使用
【从嵌入式视角学习香山处理器】四、Chisel语言基础
哎呦不错哦！
02-27 3128
chisel官方文档的笔记
枚举---Enum类
A_droid的博客
10-18 361
一，本章目标 掌握Enum关键字与Enum类的关系 了解Enum类中提供的常用方法 二，具体内容 Enum类的构造方法中接受2个参数，一个表示枚举的名字，一个表示枚举的序号。 在上一个例子中，RED表示一个枚举的名字，默认序号是0. 如果此时希望做一些改进，希望可以使用文字表示颜色的信息，则可以按照最早的Color类的形式，在枚举中定义属性和自己的构造方
chisel有限状态机(FSM)书写方法
耐心的小黑的博客
06-26 1522
状态机也是常用电路，但是Chisel没有直接构建状态机的原语。不过，chisel3.util包里定义了一个Enum特质及其伴生对象。伴生对象里的apply方法定义如下： def apply(n: Int): List[UInt] 它会根据参数n返回对应元素数的List[UInt]，每个元素都是不同的，所以可以作为枚举值来使用。 最好把枚举状态的变量名也组成一个列表，然后用列表的模式匹配来进行赋值。有了枚举值后，可以通过“switch…is…is”语句来使用。其中，switch里是相应的状态寄存器，而每个i
吃透Chisel语言.27.Chisel进阶之有限状态机（一）——基本有限状态机（Moore机）
github-3rr0r的博客
07-26 2423
有限状态机（FSM，Finite-State Machine）是数字设计中的基本构建块，数字设计中很多状态逻辑都可以抽象为FSM。这一部分将对FSM的Chisel实现进行详细介绍，除了基本有限状态机（Moore有限状态机）以外，还会学习Mealy有限状态机和并将二者进行对比。这一篇文章就首先介绍Moore有限状态机。...
精选资源
chisel3：Chisel 3：现代硬件设计语言
02-05
**Chisel 3：现代硬件设计语言** Chisel 3是一种高级硬件描述语言（HDL），它允许工程师使用类似于编程语言的方式描述数字电路系统。Chisel 3是其早期版本Chisel的升级，旨在提供更现代、更强大的功能，以支持复杂...
chisel之scala 语法
oldmoney
02-03 1496
Function可以被看作一个带parameter(参数)输入的expression block(记得上一节介绍的expression block吧)。例如，你可以定义一个名为double的函数，把输入的整形参数乘以2作为返回值。如下：上式中 x: Int表示输入parameter是一个Int类型，之后的第二个 : Int指出函数返回值也是Int类型。等号右边是一个expression，其返回值是输入参数乘以2。上面的代码可以简化成不包含返回类型，因为可以自动推导出返回类型是Int。
吃透Chisel语言.18.Chisel模块详解（五）——Chisel中使用Verilog模块
github-3rr0r的博客
07-13 3067
上一篇文章讲述了用函数实现轻量级模块的方法，可以大幅度提升编码效率。Chisel中也提供了一些好用的函数，方便我们编写代码，也方便Chisel编译器优化生成的硬件电路。在Chisel中除了使用我们写的模块或函数硬件生成器，我们可能还需要使用现有的IP，而这些IP通常是用Verilog来写的，我们该如何使用这些IP呢？这一篇文章就来说说。...
吃透Chisel语言.38.Chisel实战之以FIFO为例（三）——几种FIFO的变体的Chisel实现
github-3rr0r的博客
08-12 2188
上一篇文章对实现串口通信的最小系统做了简单阐述，然后从发送端开始，实现了基于单字节FIFO缓冲区的发送端，接着类似地实现了接收端，最后将二者综合在一起，实现了发送“Hello World!”信息的串口通信demo。虽然代码量相对之前来说多了很多，但是因为模块化设计且利用了Chisel的特性，因此条理也很清晰。这一篇文章，我们继续实现FIFO队列的几种变体，进一步实践Chisel开发。...
精选资源
Chisel-SHMAC
06-17
路由器是异构计算机最基本的部分之一，这是路由器的一种实现，它为网络中的包实现了 XY 路由路由算法。 网络中的每个瓦片都与路由器连接在一起，下图显示了路由器的详细架构。 记忆 内存是一个支持读写的简单模块，...
Chisel学习7 有限状态机
adminTa的博客
06-11 435
有限状态机（FSM）是数字设计中的基本构建块。FSM可以被描述为一组状态和状态之间的条件（保护）状态转换。FSM具有初始状态，其在复位时被设置。FSM也称为同步时序电路。FSM的实现由三部分组成：（1）保持当前状态的寄存器，（2）计算取决于当前状态和输入的下一状态的组合逻辑，以及（3）计算FSM的输出的组合逻辑。原则上，包含用于存储状态的寄存器或其他存储器元件的每个数字电路可以被描述为单个FSM。但是，这可能并不实际，例如，尝试将您的笔记本电脑描述为单个FSM。
一生一芯14——chisel环境搭建
weixin_46538207的博客
09-14 1038
本人使用的ubuntu版本为22.04anaconda 版本为23.1.0本博客参考自。
Chisel入门（三）------Chisel的基本语法1
qq_38798111的博客
03-07 3596
Chisel入门----Chisel的基本语法
Chisel 手册（中文part1）
专业技术人员的归宿
07-20 1639
Chisel 手册（part1） 作者：Jonathan Bachrach, Huy Vo, Krste Asanović； EECS Department, UC Berkeley 译者：智能物联（优快云） 1 简介 本文为Chisel手册(Constructing Hardware In a Scala Embedded Language)。Chisel是一种内置于...
Chisel手册之Types
专注计算机体系结构
05-05 1751
本文是Chisel手册第二篇Types。 Types 表示硬件设计的Chisel图包含原始节点和类型节点。Chisel类型系统与底层Scala类型系统分开维护，因此类型节点散布在原始节点之间，以允许Chisel检查并响应Chisel类型。Chisel类型节点在硬件设计转换为C ++或Verilog之前被擦除。getRawNode运算符定义在基本Node类中，跳过类型节点并返回找到的第一
Chisel常用语法汇总
最新发布
m0_74854470的博客
09-13 797
【数字集成电路与系统设计】chisel语言的基础用法
Chisel 学习笔记（三）
12-05 205
Chisel 学习笔记（三）Chisel Chisel example、测试、verilog生成 样例模块 package Passthrough import chisel3._ class MAC extends Module{ val io = IO(new Bundle{ val in_a = Input(UInt(4.W)) val ...
第十九章 Chisel基础——常用的硬件原语
热门推荐
qq_34291505的博客
02-21 2万+
前两章介绍了基本的数据类型和硬件类型，已经足够编写基本的小规模电路。至于要如何生成Verilog，会在后续章节讲解。如果要编写大型电路，当然也可以一砖一瓦地搭建，但是费时费力，完全体现不出软件语言的优势。Chisel在语言库里定义了很多常用的硬件原语，读者可以直接导入相应的包来使用。让编译器多干活，让程序员少费力。 一、多路选择器 因为多路选择器是一个很常用的电路模块，所以Chisel内建了几...
Chisel入门教程
专注计算机体系结构
05-05 1万+
Chisel的基本概念 1、Chisel硬件表达 此版本的Chisel只支持二进制逻辑，不支持三态信号。 2、Chisel数据类型 数据类型用于指定状态元素中保存的值或wire上传输的值。  类型有SInt，UInt，Bool，Bundle，Vcc。 Bundles&Vecs  Bundle和Vec是可以允许用户使用其他数据类型来扩展Chisel数据类型集合的
20201010版Chisel数字设计教程
Chisel是一种开源硬件建模语言，构建于Scala编程语言之上，用于设计可编程硬件，如FPGA和ASIC。这本书提供了深入的指导和实践案例，帮助读者掌握使用Chisel进行高级数字设计的方法。 在讨论这本书之前，让我们先...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值