【Chisel模块设计相关】

已于 2023-06-06 13:46:09 修改
阅读量394 收藏 3
点赞数 2
分类专栏： 敏捷硬件开发 文章标签： 硬件工程 开发语言 scala
于 2023-06-06 13:38:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkt19991001/article/details/131046418
版权

Chisel模块设计相关

前言

本章将继续讲解Chisel硬件设计内容，前期已经讲解了Chisel的基本语言和数据类型，以及操作符号，对基本知识不了解的读者可以查看前序文章。

本章讲述Chisel定义模块相关内容。

端口

定义端口

在Chisel中，可以使用IO对象来定义端口。

IO对象是一个包含输入和输出信号的容器，它可以在模块中被引用和连接。

如何定义一个带有输入和输出端口的模块，如下示例：

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  // 模块的逻辑部分
  // ...

  io.output := io.input
}

在上面的示例中，定义了一个名为MyModule的模块，它有一个8位的输入端口input和一个8位的输出端口output。

通过创建一个IO对象，并指定其内部的信号类型和方向，我们可以定义模块的接口。

注意，UInt(8.W)表示一个8位无符号整数类型，Input和Output指定了信号的方向。

在Chisel中，可以使用Bundle来定义自定义的端口对象，它可以包含多个信号，并以结构化的方式组织。

import chisel3._

class MyIO extends  Bundle {
	val in_1 = Input(UInt(32.W))
	val in_2 = Input(UInt(32.W))
	... ...
	val out_1 = Output(UInt(32.W))
}

class MyModule extends Moudle {
	val io = IO(new MyIO) //端口列表
}

使用Bundle可以更好地组织和管理多个信号，使得端口对象更加结构化和易于理解。

端口翻转

在Chisel中，Flipped关键字用于翻转端口的方向。它可以应用于Bundle或Data类型，将其所有的输入信号转换为输出信号，将所有的输出信号转换为输入信号。

对于需要相连的模块，很大可能存在同名但传输方向相反的端口，故此可以使用Flipped将端口翻转使用。

下面是一个示例，展示如何使用Flipped来翻转端口方向：

import chisel3._

class MyModule_1 extends Module {
  val io = IO(new MyIO)
  // 其他逻辑部分
  // ...
}

class MyModule_2 extends Module {
  val io = IO(Flipped(new MyIO))
  // 其他逻辑部分
  // ...
}

使用Flipped可以方便地翻转端口的方向，使得输入信号变为输出信号，输出信号变为输入信号，从而符合特定的设计需求。

端口连接

在 Chisel 中，可以使用 <> 运算符来进行端口连接。这个运算符允许将一个模块的输出端口连接到另一个模块的输入端口。

下面是一个简单的示例，展示了如何使用 <> 运算符连接两个模块的端口：

import chisel3._

class Source extends Module {
  val io = IO(new Bundle {
    val dataOut = Output(UInt(8.W))
  })

  // 模拟数据产生
  val data = RegInit(0.U(8.W))
  data := data + 1.U

  io.dataOut := data
}

class Sink extends Module {
  val io = IO(new Bundle {
    val dataIn = Input(UInt(8.W))
  })

  // 在控制台打印接收到的数据
  printf("Received data: %d\n", io.dataIn)
}

class Top extends Module {
  val io = IO(new Bundle {})

  val source = Module(new Source)
  val sink = Module(new Sink)

  // 使用 <> 运算符连接模块的端口
  sink.io.dataIn <> source.io.dataOut
}

在上面的例子中，有三个模块：Source、Sink 和 Top。Source 模块产生一个递增的数据，并将其输出到 dataOut 端口。Sink 模块接收数据并在控制台上打印。Top 模块将 Source 和 Sink 模块连接在一起。

在 Top 模块中，使用 <> 运算符将 Source 模块的 dataOut 端口连接到 Sink 模块的 dataIn 端口。这样，Source 模块产生的数据将通过连接传递给 Sink 模块。

使用 <> 运算符可以简化端口连接的代码，并提高代码的可读性。它是 Chisel 中常用的一种连接方式。

端口修改

可选字段法：

在 Chisel 中，可以使用 Some 来表示一个可选字段的值。Some 是 Scala 中的一个类，用于封装一个值，并表示该值存在。

下面是一个简单的示例，演示如何使用 Some 创建一个可选字段：

import chisel3._

class MyModule(myFlag:Boolean)  extends Module {
  	val io = IO(new Bundle {
    	val input = Input(UInt(8.W))
    	val output_1 = Output(UInt(8.W))
    	val output_2 = if (myFlag) Some(Output(UInt(8.W))) else None
  })
	
	if (myFlag) {
	// 使用get方法获取
		io.output_2.get := io.in
	}
}

通过使用 Some 和 get，您可以根据需要创建可选字段，并根据字段的存在与否进行端口连接。这样可以提供更大的灵活性和配置性。

Zero-Width：

在 Chisel 中，Zero-Width 表示宽度为零的信号。它可以在定义端口、信号和信号连接等场景中使用。

下面是一些示例，展示了 Zero-Width 的使用：

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(Bool())        // 单位宽度输入信号
    val output = Output(UInt(0.W))   // 零宽度输出信号
  })
}

在上面的示例中，input 是一个单位宽度的输入信号，即宽度为1。output 是一个零宽度的输出信号，宽度为0。零宽度的信号在某些情况下是有用的，比如用作控制信号、状态信号等。

使用 Zero-Width 的信号时，不能对其进行赋值或进行位操作，因为它没有具体的位数。但是，可以使用 Zero-Width 的信号进行模块之间的连接，用于表示某些特定的信号语义。

模块

模块分类

在 Chisel 中，有三种常见的模块类型：Module、MultiIOModule 和 RawModule。

    • Module：Module 是最常用的模块类型，用于定义具有输入和输出端口的硬件模块。它是 Chisel 的标准模块类型，提供了一种简洁的方式来描述模块的功能和连接。Module 继承自 MultiIOModule。
    • MultiIOModule：MultiIOModule 是 Module 的超类，它允许在模块中定义多个输入和输出端口。与 Module 类型相比，它提供了更多的灵活性，可以定义更多的端口信号。大多数情况下，使用 Module 就足够了，只有在需要定义多个端口时才需要使用 MultiIOModule。
    • RawModule：RawModule 是一个更底层的模块类型，它提供了对原始的 Verilog 原语的直接访问和使用。与 Module 和 MultiIOModule 不同，RawModule 并不提供高级抽象，而是允许直接编写和使用 Verilog 代码。这种模块类型适用于需要直接使用 Verilog 原语或与其他 Verilog 代码进行交互的情况。

大多数情况下，使用 Module 类型就可以满足设计需求，它提供了高级抽象和便捷的功能。MultiIOModule 在需要定义多个端口时很有用，而 RawModule 则适用于需要直接访问和使用 Verilog 原语的场景。选择适当的模块类型取决于设计的需求和复杂性。

模块定义

  1. Module 类是 Chisel 中用于定义硬件模块的基类，它具有以下特点：
    • 继承关系：Module 类是所有 Chisel 模块的基类，其他模块类需要继承自 Module 类。
    • 端口定义：在 Module 类中，可以通过 IO 方法定义输入和输出端口，使用 Input 和 Output 方法指定端口的方向和数据类型。
    • 层次结构：Module 类支持嵌套和层次结构，即可以在一个模块内部实例化其他模块，并将其作为子模块。这种层次结构的组织可以方便地构建复杂的硬件设计。
    • 时钟和复位：Module 类提供了 clock 和 reset 两个默认的时钟和复位信号，它们是模块中的常用信号，可以直接在模块中使用。
    • 状态和逻辑：在 Module 类中，可以定义状态变量和逻辑操作来实现模块的功能。使用 Chisel 提供的各种操作符和语法，可以编写具有复杂逻辑的硬件描述。
    • 仿真和生成：Module 类不仅可以用于在仿真环境中验证设计的正确性，还可以生成对应的硬件描述，用于实际的 FPGA 或 ASIC 实现。
import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(4.W))
    val output = Output(UInt(8.W))
  })

  // 模块的功能逻辑
  io.output := io.input + 1.U
}

Module 类是 Chisel 中用于定义硬件模块的核心类，它提供了端口定义、层次结构、时钟和复位支持以及状态和逻辑操作的能力，帮助开发者构建复杂的硬件设计。

  1. MultiIOModule 用于定义具有多个输入输出端口的模块。相比于普通的 Module 类，MultiIOModule 允许在一个模块中定义多个 IO 对象，每个 IO 对象可以包含多个输入输出端口。以下是 MultiIOModule 的特点：
    • 多个 IO 对象：使用 IO 方法可以在 MultiIOModule 中定义多个 IO 对象，每个 IO 对象代表一个输入输出接口。
    • 简化的端口定义：使用 IO 方法时，可以直接定义输入输出端口的类型和方向，而无需再使用 Bundle 进行封装。
    • 无需 Bundle 类型：与普通的 Module 不同，MultiIOModule 中的输入输出端口可以直接使用基本数据类型（如 UInt、Bool）作为其类型，而无需使用 Bundle 类型。
    • 简化的端口连接：由于每个 IO 对象代表一个接口，因此可以直接通过点运算符将模块的输入输出端口与相应的 IO 对象的端口进行连接。
import chisel3._

class MyModule extends MultiIOModule {
  val input = IO(Input(UInt(4.W)))
  val output = IO(Output(UInt(8.W)))

  // 模块的功能逻辑
  output := input + 1.U
}
  1. RawModule 提供了更底层的硬件描述能力。与普通的 Module 不同，RawModule 不提供自动生成的 io 对象，而是要求开发者手动定义所有的输入和输出端口。RawModule 的主要特点包括：
    • 自定义输入和输出端口：使用 Input、Output 或 Flipped 等方法手动定义输入和输出端口，而不使用自动生成的 io 对象。
    • 自定义信号线和寄存器：可以直接创建 Wire、Reg 等信号线和寄存器对象，并在硬件描述中进行连接和操作。
    • 更灵活的信号处理能力：可以使用原始的硬件原语和底层操作，对信号进行更细粒度的控制和处理。
import chisel3._
import chisel3.util._

class MyRawModule extends RawModule {
  // 定义输入和输出端口
  val in = IO(Input(UInt(8.W)))
  val out = IO(Output(UInt(8.W)))

  // 定义内部信号线
  val wire1 = Wire(UInt(8.W))
  val wire2 = Wire(UInt(8.W))

  // 定义寄存器
  val reg = RegInit(0.U(8.W))

  // 连接信号线和寄存器
  wire1 := in + 1.U
  wire2 := reg + 2.U
  reg := wire1 + wire2

  // 连接输出端口
  out := reg
}

由于 RawModule 提供了更底层的硬件描述能力，它在某些特定场景下非常有用，例如需要与外部接口进行底层硬件通信的模块设计。然而，由于需要手动定义所有的端口和信号线，相对于使用 Module 进行高级抽象的描述方式，编写和维护代码可能会更加繁琐和复杂。

模块例化

在 Chisel 中，模块的实例化可以通过使用 Module 类的构造函数来完成。

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  // 模块的实现

  // 例如，将输入信号直接赋值给输出信号
  io.output := io.input
}

// 模块实例化
val myModule = Module(new MyModule())

// 使用实例的端口进行连接
myModule.io.input := inputSignal
outputSignal := myModule.io.output

在上面的示例中，首先定义了一个继承自 Module 的自定义模块 MyModule。在模块内部，通过 IO 函数定义了输入和输出端口。然后，在模块实例化阶段，通过调用 Module 构造函数来创建 MyModule 的一个实例 myModule。最后，可以使用实例的端口与其他信号进行连接。

需要注意的是，Chisel 的模块实例化是通过调用构造函数创建对象的方式进行的，而不是传统的 Verilog 中的实例化语法。此外，Chisel 中的模块实例化是静态的，即模块在运行时实例化一次，而不支持动态的实例化。

同时也可以使用 VecInit 来实例化多个模块。VecInit 函数接受一个包含多个元素的序列，并将其转换为 Chisel 的 Vec 类型。

以下是一个使用 VecInit 实例化多个模块的示例：

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  // 模块的实现

  // 例如，将输入信号直接赋值给输出信号
  io.output := io.input
}

// 定义模块数量
val numModules = 4

// 实例化多个模块并连接
val myModules = VecInit(Seq.fill(numModules)(Module(new MyModule()).io))

// 使用实例的端口进行连接
for (i <- 0 until numModules) {
  myModules(i).input := inputSignals(i)
  outputSignals(i) := myModules(i).output
}

使用 VecInit 和 Seq.fill 创建了一个包含多个 MyModule 实例的 Vec，其中 numModules 定义了模块的数量。接下来，通过循环遍历模块实例，使用实例的端口进行连接。

通过使用 VecInit 和 Seq.fill，可以方便地一次性实例化多个模块，并进行模块之间的信号连接。

线网

Wire

在 Chisel 中，wire 是用于声明信号连接的关键字。它用于声明一个连接两个或多个电路元件的信号线。

在 Chisel 中，可以使用 wire 关键字来声明一个信号，并在后续的逻辑中对其进行操作和连接。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  // 声明一个 wire
  val myWire = Wire(UInt(8.W))

  // 对 wire 进行操作
  myWire := io.input + 1.U

  // 将 wire 连接到输出端口
  io.output := myWire
}

使用 wire 关键字可以方便地声明信号，并在逻辑中对其进行操作和连接，使得电路设计更加清晰和可读。

WireDefault

在 Chisel 中，可以为 Wire 类型的信号提供默认值。为 Wire 提供默认值可以确保在电路中的所有位置，如果信号未被显式地赋值，那么它将具有预定义的默认值。

为了为 Wire 类型的信号提供默认值，可以使用 WireDefault 类。WireDefault 类包装了 Wire 类型的信号，并为其提供默认值。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  // 声明一个带有默认值的 wire
  val myWire = WireDefault(0.U(8.W))

  // 对 wire 进行操作
  myWire := io.input + 1.U

  // 将 wire 连接到输出端口
  io.output := myWire
}

使用 WireDefault 类为 myWire 提供了默认值为 0 的 8 位无符号整数。如果 myWire 未在电路中的任何位置被显式地赋值，它将保持默认值。

通过为 Wire 类型的信号提供默认值，可以确保在电路中的所有位置，信号都具有预定义的默认值，从而增加了电路的可靠性和可维护性。

线网驱动

在 Chisel 中，可以使用 Wire 或 Reg 定义线网（wire）或寄存器（register），然后使用 := 运算符将信号驱动到线网或寄存器上。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

  val myWire = Wire(UInt(8.W))  // 定义一个线网

  myWire := io.input  // 驱动线网

  io.output := myWire  // 连接线网到输出端口
}

使用 Wire 定义了一个 8 位无符号整数的线网 myWire。然后，使用 := 运算符将 io.input 信号驱动到 myWire 上。最后将 myWire 连接到输出端口 io.output。

如果一个线网没有被显式地驱动，那么它将被认为是未驱动的（unconnected）。

未驱动的线网可能会导致逻辑错误或仿真问题，因为它们没有定义明确的值。为了避免未驱动的线网，通常需要确保每个线网都有合适的驱动。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

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

  // 驱动线网之前进行默认值赋值
  myWire := 0.U

  myWire := io.input
  io.output := myWire
}

驱动线网之前，对 myWire 进行了默认值赋值，确保它在被驱动之前具有明确的值。

请注意，在某些情况下，未驱动的线网可能是有意为之，例如在设计中使用了高阻抗（Z）状态。在这种情况下，可以使用 DontCare 表示线网的值不重要。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val input = Input(UInt(8.W))
    val output = Output(UInt(8.W))
  })

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

  myWire := DontCare // 表示线网的值不重要

  io.output := myWire
}

使用 DontCare 将 myWire 的值设置为不重要，表示我们不关心它的具体值。

此外还可以通过一些设置，CompileOptions 用于设置编译选项，它允许你为 Chisel 编译器提供一些特定的配置和指令。

CompileOptions 是一个 ChiselExecutionOptions 对象，它可以用于配置编译过程中的各种选项，例如设置生成的 Verilog 文件的输出路径、指定需要引用的外部库等，同时可以设置检查机制。

class MyModule extends Module {
	// 严格检测
	override val compileOptions = chisel3.ExplicitCompileOptions.NotStrict.copy(explicitInvalidate = true)
	// 不严格检查
	override val compileOptions = chisel3.ExplicitCompileOptions.NotStrict.copy(explicitInvalidate = false)
}

开启检查时，编译过程中会产生not fully initialized错误，组合逻辑真值表不完整，不能综合出完整电路。

寄存器

在 Chisel 中，可以使用 Reg 类型来定义寄存器。Reg 类型是 Chisel 提供的一种特殊类型，用于表示寄存器。

import chisel3._

class MyModule extends Module {
  val io = IO(new Bundle {
    val dataIn = Input(UInt(8.W))
    val dataOut = Output(UInt(8.W))
  })

  val myReg = RegInit(0.U(8.W)) // 定义一个8位宽的寄存器，并初始化为0

  myReg := io.dataIn // 将输入数据写入寄存器
  io.dataOut := myReg // 将寄存器数据输出
}

使用 RegInit 函数定义了一个8位宽的寄存器 myReg，并将其初始化为0。然后，使用 := 运算符将输入信号 io.dataIn 的值赋给寄存器。最后，将寄存器的值赋给输出信号 io.dataOut。

需要注意的是，Chisel 中的寄存器是同步元素，其更新操作通常在时钟的上升沿或下降沿发生。在时序电路中，需要将寄存器的更新操作放置在适当的时钟域和时钟触发条件下，以确保正确的时序行为。

除了使用 RegInit 初始化寄存器外，还可以使用其他函数和语法来定义和操作寄存器，如 RegNext、RegEnable 等。这些函数提供了更多的灵活性和功能，可以根据具体的设计需求进行选择和使用。

电路赋值

在硬件设计中，"when"是Chisel中用于条件赋值的关键字。它类似于其他编程语言中的"if-else"语句，用于在特定条件下对信号进行赋值操作。

when(condition) {
  // 赋值语句
}

其中，"condition"是一个布尔表达式，用于指定条件。当条件为真时，会执行大括号中的赋值语句。

下面演示如何在Chisel中使用"when"进行条件赋值：

val a = Wire(UInt(4.W))
val b = Wire(UInt(4.W))
val result = Wire(UInt(4.W))

when(a > b) {
  result := a
}.otherwise {
  result := b
}

在上面的示例中，根据条件"a > b"的真假，将变量"result"赋值为变量"a"或变量"b"。

“when"语句还可以与其他控制流语句结合使用，如"else"和"elsewhen”，以实现更复杂的条件逻辑。

总结

o(▽)o

Kiri1001
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Chisel Tutorial（七）——模块
leishangwen的专栏
08-18 2396
Chisel中的模块与Verilog HDL中模块的概念十分相似，都是用层次结构描述电路。Chisel中的module是一个类，其定义遵循以下几点：  继承自Module类， 有一个命名为io的端口， 在其构造函数中连接子电路 如下是一个2选1选择器的模块定义：
【Chisel】2.1创建第一个模块：Chisel官方教学，记录学习。
快乐学习小猪猪的博客
03-14 1614
前言 Chisel指的是Constructing Hardware In a Scala Embedded Language(建立在Scala嵌入式语言基础之上的硬件语言)。在学习的过程中，需要充分的理解和区分哪些code是Chisel而哪些是Scala。现在可以简单把Chisel想象成一种更方便写verilog的语言。 配置环境 val path = System.getProperty("user.dir") + "/source/load-ivy.sc" interp.load.module(ammo
学习github上的chisel教材之Module 2.1: Your First Chisel Module¶
yjn18021006815的博客
10-25 378
1、Chisel stands for Constructing Hardware In a Scala Embedded Language（chisel 是 嵌在Scala上的硬件构造语言）意味着它是Scala中的DSL，使您可以在同一代码中利用Scala和Chisel编程，同时 了解哪个代码是“ Scala”和哪个代码是“ Chisel”很重要。 2、该模块将为您提供整个Chisel模块和test case 。 //为Chisel下载所需要的依赖项 val path = System.getPrope
吃透Chisel语言.14.Chisel模块详解（一）——初识Chisel模块（Module）并实现一个计数器
github-3rr0r的博客
07-08 1776
Chisel模块详解这一部分会讲解组件在Chisel中是怎么描述的、又是如何整合到一起的，还提供了一些简单的组件的例子。不过这一部分涉及到的模块还都比较小，比如一个简单的加法器，只是用来展示定义、实例化和连接组件的基本原理。实际编写Chisel代码的时候，要写的模块肯定代码量大管饱，不像加法器一样就那么一两行。这一篇文章首先介绍Chisel的基本组件，也就是模块（Module）。...
吃透Chisel语言.17.Chisel模块详解（四）——用函数实现轻量级模块
github-3rr0r的博客
07-13 1174
前面三篇文章我们学习了模块的实现语法、模块嵌套以及模块之间的连接方法，一般来说模块是Chisel中构造硬件描述的基本方法。但是Chisel中的模块和Verilog这类语言一样，定义模块会需要很多样板代码，又是从`Module`拓展，又是定义`IO`接口的，实例化和连接的时候又很费劲。不过Chisel中还是有简单的方法来定义轻量级模块的，那就是使用函数来实现。这一篇文章就讲讲如何用函数实现轻量级模块。...
chisel3：Chisel 3：现代硬件设计语言
02-05
Chisel 3鼓励模块化设计，使得硬件模块可以被多次复用。此外，`chisel-gen`工具允许开发者自动化生成整个芯片的顶层模块，将多个子模块集成在一起，大大提高了设计效率。 **综合与验证** 生成的Verilog代码经过...
Chisel-Scala.rar
02-23
Scala的强类型和面向对象特性使得Chisel能够提供一种更加模块化和可读性强的方式来设计复杂的硬件系统。 **Scala语言基础** Scala是一种多范式的编程语言，融合了函数式和面向对象编程的特点。它的语法简洁且强大...
chisel-template-release.zip
05-11
Chisel是一种高级的硬件描述语言，专为构建结构化、可读性强的数字系统设计而设计。它被广泛应用于RISC-V（Reduced Instruction Set Computer - Version V）指令集架构的实现，这是一种开放源码的处理器架构，具有...
paso：Chisel集成规范和验证语言
02-20
1. **面向对象**：Chisel利用Scala的面向对象特性，使硬件设计更具有模块化和可复用性。 2. **类型安全**：与传统的硬件描述语言不同，Chisel在编译时就能检测错误，提高了设计的可靠性。 3. **动态构造**：Chisel...
20200722-Circuit-Capture-of-Chisel-p1-Correctness.pdf
12-16
主要包括Chisel中的电路捕获（Circuit Capture）概念、DecCounter模块的具体实现以及Chisel语言内部的一些细节。 ### 一、电路捕获（Circuit Capture） 电路捕获是Chisel中一个重要的概念，它是指通过Chisel编写的...
chisel-template
04-17
凿子项目模板 您已经完成了 ，现在就可以开始自己的Chisel项目了。 以下过程应使您开始运行干净的项目。 制作自己的Chisel3项目 依存关系 JDK 8或更高版本 我们建议LTS发行Java 8和 。您可以按照操作系统的建议安装JDK，也可以使用的预构建二进制文件。 SBT SBT是Scala社区中最常见的内置工具。 您可以下载。 如何开始 从模板创建存储库 该存储库是Github模板。 您可以通过单击右上角的绿色“ Use this template来从中创建自己的存储库。 请取消选中Include all branches ; 对其进行检查将污染您新存储库的历史记录。 有关更多信息，请参见 。 等待模板清理工作流完成 使用模板创建自己的空白项目后，请等待一两分钟，以运行Template cleanup工作流，这将从存储库中删除一些模板特定的内容（例如LICENSE）。 在您的浏
chisel端口（IO）与模块（Module）使用详解（更新）
耐心的小黑的博客
06-25 3444
一、端口(类似于verilog中的input、output) Ⅰ、定义端口列表 定义一个模块前一定要先定义好端口。整个端口列表是由方法“IO[T <: Data](iodef: T)”来定义的，通常其参数是一个Bundle类型的对象，而且引用的字段名称必须是“io”。因为端口存在方向，所以还需要方法“Input[T <: Data](source: T)”和“Output[T <: Data](source: T)”来为每个端口表明具体的方向。注意，“Input[T <: Data]
Chisel教程——13.Scala的面向对象编程特性和Chisel中的Module
github-3rr0r的博客
05-17 953
Scala和Chisel都是面向对象的编程语言，这意味着代码可以被组织为对象。Scala是在Java上编译的，继承了Java中很多面向对象的特性，不过下面我们会看到还是有些区别的。Chisel的硬件模块和Verilog中的模块类似，尤其是他们可以被实例化和连线为单个或多个示例。用好面向对象特性，那基本可以轻松点解决项目中绝大多数问题了。...
吃透Chisel语言.16.Chisel模块详解（三）——Chisel的整体连接（Bulk Connection），以流水线处理器为例
github-3rr0r的博客
07-13 2111
一般来说，一个Chisel模块都会有很多端口，为了连接多端口的模块，要是一根线一根线地连接就会很麻烦。而Chisel中提供了**整体连接**（Bulk Connection）操作符``，可以将bundle的部分给双向连接起来，这样我们在连接组件的时候就可以用一个操作符就行了，方便很多。这一篇文章我们就来讲讲这个``操作符的用法。...
第十八章 Chisel基础——模块与硬件类型
qq_34291505的博客
02-21 1万+
Chisel在构建硬件的思路上类似Verilog。在Verilog中，是以“模块(module)”为基本单位组成一个完整的独立功能实体，所以Chisel也是按模块划分的，只不过不是用关键字“module”开头来定义模块，而是用一个继承自Module类的自定义class。 在Verilog里，模块内部主要有“线网(wire)”和“四态变量(reg)”两种硬件类型，它们用于描述数字电路的组合逻辑和时...
Chisel入门------Chisel的基本语法4
最新发布
qq_38798111的博客
03-13 492
本节将具体的介绍集中常见的硬件电路，并探索如何使用Chisel语言进行描述。
Chisel教程——11.用Scala的高阶函数让Chisel代码更优雅
github-3rr0r的博客
05-17 1886
前面模块中讨厌的`for`循环很冗长，破坏了函数式编程的目的，这一篇将会介绍高阶函数，让我们写生成器的时候更快。
第十六章 Chisel入门——搭建开发环境
热门推荐
qq_34291505的博客
02-15 2万+
用于编写Chisel的Scala内容已经全部讲完了，下面就可以正式进入Chisel的学习之旅了。有兴趣的读者也可以自行深入研究Scala的其它方面，不管是日后学习、工作，或是研究Chisel发布的新版本，都会有不少的帮助。 在学习Chisel之前，自然是要先讲解如何搭建开发环境。因为目前还没有Windows系统的开发环境，所以读者最好有一个Linux系统的虚拟机，或者Mac OS的电脑。在这里，...
scala 常用函数（持续更新）
withme的博客
06-01 1049
1.时间转日期val sdf = new SimpleDateFormat("yyyyMMdd") val date = sdf.format(new Date(time * 1000)) //转成毫秒
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Kiri1001

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值