spinal HDL - 11 - 使用状态机语法编写“1001“序列检测

已于 2022-08-16 21:51:18 修改
阅读量2.4k 收藏 9
点赞数 2
分类专栏： # spinal HDL 文章标签： fpga开发 嵌入式硬件 spinal HDL
于 2022-08-16 21:46:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41445387/article/details/126374981
版权
本文介绍了如何使用SpinalHDL库编写Mealy型状态机，以实现1001序列检测器。通过对比Verilog代码，展示了SpinalHDL的简洁性和易读性，并提供了生成的Verilog代码以供分析。此外，还提到了代码的仿真验证，证明其功能与手写代码一致。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言

了解了在spinal HDL中如何利用scala语言进行状态机编写后，本文通过“1001”序列检测器的代码进行练习状态机的编写。

序列检测要求

检测1001序列，输入信号din依次输入1、0、0、1，当检测到完整序列后dout进行输出，使用mealy型状态机进行编写。

任务分析

对于使用Verilog的状态机编写，首先需要画状态转移图，然后根据状态转移图使用三段式状态机进行描述。

而对于spinal HDL来说，根据前文的讲述的语法规则，在完成状态转移图后，也需要根据状态转移图进行状态机描述。这里我根据三段式的思路，也大致分成三段：

  1. new 一个状态机 StateMachine 的val，new 需要的状态并指定状态机的入口。
  2. 根据spinal HDL的语法进行编写状态转移
  3. 根据实际需求，设计判断条件进行输出。

编写代码

为了对比spinal HDL的代码和Verilog代码的异同，首先给出一份手写的mealy型状态机的序列检测器。

module mealy_1001(clk,rst_n,din,dout,state_c,state_n
    );
	input           clk   	    ;
	input           rst_n		;
	input           din	        ;
	output      reg dout        ;
	output    [2:0] state_c     ;
	output    [2:0] state_n     ;
	
	reg       [2:0] state_c     ;//现态
	reg       [2:0] state_n     ;//次态
	//状态变量赋值
	parameter       S0 =3'b000,
					S1 =3'b001,
					S2 =3'b010,
					S3 =3'b100;
	//状态跳转
	always@(posedge clk or negedge rst_n)begin
		if(rst_n==1'b0)begin
			state_c <=S0;
		end
		else begin
			state_c <= state_n;
		end
	end
	//状态转移条件判断
	always@(*)begin
		case(state_c)
			S0:
				if(din==1'b1)begin
					state_n=S1;
				end
				else begin
					state_n=S0;
				end
			S1:
				if(din==1'b0)begin
					state_n=S2;
				end
				else begin
					state_n=S1;
				end
			S2:
				if(din==1'b0)begin
					state_n=S3;
				end
				else begin
					state_n=S1;
				end
			S3:
				if(din==1'b1)begin
					state_n=S1;
				end
				else begin
					state_n=S0;
				end
			default:state_n=S0;
		endcase
	end
	//输出模块
	always@(posedge clk or negedge rst_n)begin
		if(rst_n==1'b0)begin
			dout<=1'b0;
		end
		else if((state_c==S3)&&(din==1'b1))begin
			dout<=1'b1;
		end
		else begin
			dout<=1'b0;
		end
	end
endmodule

然后，根据硬件状态机的设计思路，编写spinal HDL的状态机代码。下面代码为mealy型状态机。相比Verilog的代码版本更像伪代码。这里按照上述的三段式的思路，编写序列检测功能。

import spinal.core._
import spinal.lib._
import spinal.lib.fsm._
case class mealy_1001() extends Component {
  //定义一个输入输出的端口束
  val io = new Bundle {
    val din = in Bits (1 bit)
    val dout = out Bits (1 bit)
  }
  //消除掉生成的代码前缀
  noIoPrefix()
  
  //1-创建一个状态机
  val fsm = new StateMachine{
    //定义状态，并指定状态机的入口
    val S0 = new State with EntryPoint
    val S1 = new State
    val S2 = new State
    val S3 = new State
    //定义一个寄存器用于存储dout的值
    val reg1: Bits = Reg(Bits(1 bit)).init(0)

    //将输出的dout和寄存器reg1绑定一起
    io.dout := reg1
      
    //2-状态转移
    S0.whenIsActive{
        when(io.din === 1) {
          goto(S1)
        }.otherwise(goto(S0))
      }

    S1.whenIsActive {
        when(io.din === 0) {
          goto(S2)
        }.otherwise(goto(S1))
      }
    S2.whenIsActive {
      when(io.din === 0) {
        goto(S3)
      }.otherwise(goto(S1))
    }
    S3.whenIsActive {
      when(io.din===1){
        goto(S1)
      }.otherwise{
        goto(S0)
      }
    }
    
    //3-输出段
    when(io.din === 1&&isActive(S3)) {
      reg1:= 1
    }.otherwise(reg1:= 0)
  }

}
//生成Verilog代码
object mealy_1001APP extends App{
  SpinalConfig(
    anonymSignalPrefix = "tmp"
  ).generateVerilog(mealy_1001())
}

运行代码可以生成spinal HDL自动生成的Verilog版本的代码。在intelliJ中运行可编译生成v代码。

生成V代码分析

相比手写版本的代码，使用spinal语法生成的代码多了fsm_wantStart，fsm_wantKill，这两部分是和对应一段状态机的开始和停止。因为对于自动生成的代码中开始的默认状态是BOOT，该状态没有用户设计的状态转移的功能。其余部分的代码对比手写版本的状态机，基本和手写的效果相当。

`define fsm_enumDefinition_binary_sequential_type [2:0]
`define fsm_enumDefinition_binary_sequential_fsm_BOOT 3'b000
`define fsm_enumDefinition_binary_sequential_fsm_S0 3'b001
`define fsm_enumDefinition_binary_sequential_fsm_S1 3'b010
`define fsm_enumDefinition_binary_sequential_fsm_S2 3'b011
`define fsm_enumDefinition_binary_sequential_fsm_S3 3'b100


module mealy_1001 (
  input      [0:0]    din,
  output     [0:0]    dout,
  input               clk,
  input               reset
);
  wire                fsm_wantExit;
  reg                 fsm_wantStart;
  wire                fsm_wantKill;
  reg        [0:0]    fsm_reg1;
  wire                when_fsm_01_l45;
  reg        `fsm_enumDefinition_binary_sequential_type fsm_stateReg;
  reg        `fsm_enumDefinition_binary_sequential_type fsm_stateNext;
  wire                when_fsm_01_l23;
  wire                when_fsm_01_l29;
  wire                when_fsm_01_l34;
  wire                when_fsm_01_l39;
  `ifndef SYNTHESIS
  reg [63:0] fsm_stateReg_string;
  reg [63:0] fsm_stateNext_string;
  `endif


  `ifndef SYNTHESIS
  always @(*) begin
    case(fsm_stateReg)
      `fsm_enumDefinition_binary_sequential_fsm_BOOT : fsm_stateReg_string = "fsm_BOOT";
      `fsm_enumDefinition_binary_sequential_fsm_S0 : fsm_stateReg_string = "fsm_S0  ";
      `fsm_enumDefinition_binary_sequential_fsm_S1 : fsm_stateReg_string = "fsm_S1  ";
      `fsm_enumDefinition_binary_sequential_fsm_S2 : fsm_stateReg_string = "fsm_S2  ";
      `fsm_enumDefinition_binary_sequential_fsm_S3 : fsm_stateReg_string = "fsm_S3  ";
      default : fsm_stateReg_string = "????????";
    endcase
  end
  always @(*) begin
    case(fsm_stateNext)
      `fsm_enumDefinition_binary_sequential_fsm_BOOT : fsm_stateNext_string = "fsm_BOOT";
      `fsm_enumDefinition_binary_sequential_fsm_S0 : fsm_stateNext_string = "fsm_S0  ";
      `fsm_enumDefinition_binary_sequential_fsm_S1 : fsm_stateNext_string = "fsm_S1  ";
      `fsm_enumDefinition_binary_sequential_fsm_S2 : fsm_stateNext_string = "fsm_S2  ";
      `fsm_enumDefinition_binary_sequential_fsm_S3 : fsm_stateNext_string = "fsm_S3  ";
      default : fsm_stateNext_string = "????????";
    endcase
  end
  `endif

  assign fsm_wantExit = 1'b0;
  always @(*) begin
    fsm_wantStart = 1'b0;
    case(fsm_stateReg)
      `fsm_enumDefinition_binary_sequential_fsm_S0 : begin
      end
      `fsm_enumDefinition_binary_sequential_fsm_S1 : begin
      end
      `fsm_enumDefinition_binary_sequential_fsm_S2 : begin
      end
      `fsm_enumDefinition_binary_sequential_fsm_S3 : begin
      end
      default : begin
        fsm_wantStart = 1'b1;
      end
    endcase
  end

  assign fsm_wantKill = 1'b0;
  assign dout = fsm_reg1;
  assign when_fsm_01_l45 = ((din == 1'b1) && (fsm_stateReg == `fsm_enumDefinition_binary_sequential_fsm_S3));
  always @(*) begin
    fsm_stateNext = fsm_stateReg;
    case(fsm_stateReg)
      `fsm_enumDefinition_binary_sequential_fsm_S0 : begin
        if(when_fsm_01_l23) begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S1;
        end else begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S0;
        end
      end
      `fsm_enumDefinition_binary_sequential_fsm_S1 : begin
        if(when_fsm_01_l29) begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S2;
        end else begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S1;
        end
      end
      `fsm_enumDefinition_binary_sequential_fsm_S2 : begin
        if(when_fsm_01_l34) begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S3;
        end else begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S1;
        end
      end
      `fsm_enumDefinition_binary_sequential_fsm_S3 : begin
        if(when_fsm_01_l39) begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S1;
        end else begin
          fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S0;
        end
      end
      default : begin
      end
    endcase
    if(fsm_wantStart) begin
      fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_S0;
    end
    if(fsm_wantKill) begin
      fsm_stateNext = `fsm_enumDefinition_binary_sequential_fsm_BOOT;
    end
  end

  assign when_fsm_01_l23 = (din == 1'b1);
  assign when_fsm_01_l29 = (din == 1'b0);
  assign when_fsm_01_l34 = (din == 1'b0);
  assign when_fsm_01_l39 = (din == 1'b1);
  always @(posedge clk or posedge reset) begin
    if(reset) begin
      fsm_reg1 <= 1'b0;
      fsm_stateReg <= `fsm_enumDefinition_binary_sequential_fsm_BOOT;
    end else begin
      if(when_fsm_01_l45) begin
        fsm_reg1 <= 1'b1;
      end else begin
        fsm_reg1 <= 1'b0;
      end
      fsm_stateReg <= fsm_stateNext;
    end
  end
endmodule

仿真验证

编写一个验证代码，输入序列，观察输出能正常输出序列检测到的指示信号，证明spinal HDL生成的代码功能正常。

image-20220816214928289

小结

  1. 使用spinal HDL的生成代码虽然有部分自认为“冗余”的部分，但是完全不影响实际的阅读，几乎和手写的代码相当。
  2. 极大地减小了在手动编写Verilog中时的冗余工作量。
  3. 经过仿真验证，代码功能和手写一致。
在win10上安装spinal hdl完全教程(一篇文章就够了)
youzjuer的博客
07-28 622
SpinalHDL 开发环境搭建一篇文章足够了（图文版）
spinal HDL语法学习
youzjuer的博客
07-28 250
scala spinal hdl语法学习
1001序列检测器（图）
04-04
图片展示1001序列检测器，简明易懂，形象生动。
1001序列检测器（mealy机）
04-04
利用JK触发器设计，输入一段信号，每当检测到1001后输出高电压。
介绍一下 SpinalHDL
最新发布
luoganttcc的博客
03-12 520
还有用户可能关心它和Chisel的区别，参考内容里提到SpinalHDL直接生成Verilog，而Chisel需要经过Firrtl转换，生成的代码可读性不如Spinal。需要结构清晰，分点说明核心特性、优势、设计流程、应用场景和与Chisel的对比，避免使用技术术语过多，让读者容易理解。作为 Scala 的库，SpinalHDL 继承了 Scala 强大的函数式编程、类型系统和元编程能力，支持复杂的参数化设计和高层次抽象（如总线封装、流水线自动生成）。：模块例化时自动完成信号连接，减少手动连线的错误。
1001序列检测器
m0_54240221的博客
04-04 9474
multisim仿真文件：1001序列检测器（mealy机）-单片机文档类资源-CSDN下载 modelsim仿真文件：1001序列检测器modelsim仿真和测试文件-单片机文档类资源-CSDN下载 实验报告：1001序列检测器实验报告-单片机文档类资源-CSDN下载 电 子 科 技 大 学 课程设计名称： 1001序列检测器 设计要求 设计一个两位十进制数的BCD码检测器，待检测的两位十进制数来自每组某位同学的学号最后2位数。当检测到待测序列后，输出为高电平，否则输出为0。要.........
【数字电子技术实验】JK触发器设计1001序列检测器
周文龙的博客
05-29 2615
写出序列检测器的设计过程，画出化简后的状态转移图。将序列检测器的工作过程填入表中。1. 熟悉触发器的结构、工作原理和特点。3. 掌握用触发器构成序列检测器的方法。2. 掌握基本JK触发器的逻辑功能。
有限状态机之1001序列检测器
(o-ωｑ)).oO 困
10-20 1万+
1001序列检测器 设计一个“1001”串行数据检测器。 其输入、输出如下所示： 输入 x：000 101 010 010 011 101 001 110 101 输出 z：000 000 000 010 010 000 001 000 000 Verilog源码 //1001序列检测器 module fsm_seq1001(clk,clr,x,z); input clk,clr,x; out...
Spinal-browser-graph-inspector
03-21
"Spinal-browser-graph-inspector" 是一个专门针对JavaScript开发的浏览器图形化调试工具。这个工具主要帮助开发者在浏览器环境中可视化地检查和分析程序中的数据结构，特别是那些复杂的数据流和依赖关系，例如...
Spinal HDL学习资源
yinyeyy的专栏
12-24 2885
最近开始接触SpinalHDL，所以收集了一些不错的学习资源，可供大家参考。 SpinalHDL是基于Scala语言开发的设计语言，使用SpinalHDL需要对Scala有一定了解。下面的两篇博文非常全面而又简洁的介绍了Scala，对上手非常有帮助。 https://vvviy.github.io/2018/12/01/Learning-Chisel-and-Scala-Part-I/ https://vvviy.github.io/2018/12/12/Learning-Chisel-and-Sca
spinal-studies-rjah-site
04-19
自述文件 这是的github回购。 初始设置 安装或升级R和RStuido 从此处为您的操作系统安装R： : 如果您已经安装了R，则可以通过从R控制台运行以下命令来检查您的版本是否为最新版本： R.version.string ...
1001序列检测器实验报告
04-04
1001序列检测器实验报告，内含modelsim仿真代码和测试代码，Multisim仿真截图。
使用D触发器设计一个11001序列检测器.pdf
10-04
使用D触发器设计一个11001序列检测器.pdf
1001序列检测器modelsim仿真和测试文件
04-04
利用modelsim软件工具，将仿真文件和测试文件放入程序中，即可运行序列检测器，并做出仿真波形。
序列检测器（1110010）
05-25
本设计使用状态机设计一个二进制序列检测器，其功能是检测一个7位的二进制序列“1110010”，即输入序列如果连续的7位为“1110010”时，输出为1，其他情况下为0。
序列检测器实验报告
12-22
序列检测器实验报告 verilog 图形分析
quartus仿真19：JK触发器序列1001检测器
Never Give Up
10-14 7018
给出电路图分析所产生的序列 分析方法按书本上的来，根据JK端的激励方程得到转移方程，代入特征方程得到状态转移表，01代表输入1，10代表输入10，11代表输入100，写出该电路功能检测序列1001 仿真输出波形如图所示 这两天是很多保研同学成绩结果出来的日子，作为在大学成绩不好的废物，恭喜别人也没人理我，我决定从这篇开始，每天都练习数电题目的仿真。另外我在硬禾课堂看见用FPGA学习数电的课程，仿真环境用Lattice，埋个坑在这儿。 ...
序列检测器1
热门推荐
prince1991的专栏
12-14 1万+
华中农业大学理学院计算机系 实验题目：      设计串行数据检测器 实验说明：      设计一个“1001”串行数据检测器。使得但输出序列中出现“1001”时，结果中就输出1。输入/输出如下所示： 输入x：000 101 010 010 011 101 001 110 101 输出z：000 000 000 010 010 000 001 000 000 实验分析：  初始状态
状态机（FSM）的介绍--以检测序列1001为例
啦啦啦啦啦
11-02 7373
有限状态机 （FSM-Finite State Machine）,是做微控器的核心，其输出值取决于过去的输入以及当前的输入，是时序组合逻辑的组合。其含有一组具有“记忆”功能的寄存器，其功能为记忆有限状态机内部的状态，被称为状态寄存器。其中时序逻辑功能是储存有限状态机的内部状态，组合逻辑功能分为 次态产生逻辑：用于确定有限状态机的下一个状态 输出逻辑：确定有限状态机的输出 分为Moore型和...
spinal hdl 例子
09-14
Spinal HDL 是一种用于硬件设计的HDL语言（硬件描述语言），它的目标是提供一种比传统VHDL或Verilog更高级、更易读、更易写的硬件描述方式。Spinal HDL 与 Scala 语言紧密集成，它允许设计师利用 Scala 的强大特性来描述硬件结构。 下面是一个简单的Spinal HDL的例子，描述了一个简单的寄存器： ```scala import spinal.core._ import spinal.core.sim._ class SimpleRegister extends Component { val io = new Bundle { val dataIn = in Bits(8 bits) val dataOut = out Bits(8 bits) val writeEnable = in Bool() } val reg = Reg(Bits(8 bits)) init(0) when(io.writeEnable) { reg := io.dataIn } io.dataOut := reg } ``` 在这个例子中，首先导入了 `spinal.core._` 和 `spinal.core.sim._` 包，这样就可以使用Spinal HDL提供的所有构造函数和模拟工具了。定义了一个名为 `SimpleRegister` 的组件，它有一个数据输入端口 `dataIn`，一个数据输出端口 `dataOut`，以及一个写使能端口 `writeEnable`。 在组件的内部，定义了一个8位宽的寄存器 `reg`。使用 `Reg` 函数声明了一个寄存器，并通过 `init` 参数初始化为0。`when` 语句用于条件判断，当 `writeEnable` 为真时，将输入数据 `dataIn` 写入寄存器 `reg`。最后，输出端口 `dataOut` 被赋予了寄存器 `reg` 的值。 Spinal HDL 通过这样的结构化语法，使得硬件设计可以更接近软件编程的风格，但同时保持了硬件描述的清晰和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

FPGA and ICer

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

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

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

打赏作者

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

抵扣说明：

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

余额充值