devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【 FPGA 】序列检测器 11010 (mealy状态机，moore状态机)_状态机实验(实现序列发生器11010100的设计)

作者：我家小花儿 | 2024-05-25 13:58:14

赞

踩

状态机实验(实现序列发生器11010100的设计)

1.mealy状态机和moore状态机me

        状态机是硬件电路设计的常用的描述工具，也是电路设计的重要思想。很早之前我就知道mealy状态机和moore状态机，但是对两者的差别不是非常的清楚，最近在学习系列检测器的设计时对这两种状态机和一段式、三段式状态机有了更深刻的了解，在这里分享自己的见解给大家。有什么理解不准确的地方也希望大家指正。

1.1序列检测器

        在介绍两种状态机之前首先先介绍一下序列检测器。

        序列检测器：从一串数据流中找到需要检测的序列号。例如如下一串数据流，需要检测的序列为11010，则每一次检测到11010时序列检测器需要输出一次使能。

9ab5e22aae8540ccbbd6a57138f57c58.png        设计该电路就可以使用状态机来实现。接下来讲解两种状态机区别和用这两种状态机实现该电路的状态图。

1.2.mealy状态机和moore状态机区别

        mealy状态机：输出由当前状态机状态和控制信号共同决定。

        moore状态机：输出仅仅取决于当前的状态机状态。

        下图时两种状态机的状态转移图 

3a785cd07e4f4685bdb6e76b7ba33563.png

7038a8a3363b477ca34409c71717da56.png

        首先解释两种状态机的工作：

        1.mealy状态机：s0状态表示一个最初状态，该状态检测到1表示序列11010的第一个1被检测到，跳转到s1，此时需要检测11010的第二个1，当在检测到第二个1时，跳转到s2，一次类推到跳转到s4，此时如果下一时刻检测到0，则表示检测到了所需要的序列，输出正确。

具体状态解释：s0：等待检测第一个需要的序列

                        s1：已经检测到1，等待检测到第二位1

                        s2：已经检测到11，等待检测第三位0    

                        s3：已经检测到110， 等待检测第四位1

                        s4：已经检测到1101，等待检测第五位0

        检测成功条件：状态机处于s4状态，并且下一个时刻输入的检测信号是0

        2.moore状态机：s0表示一个空闲状态，该状态等待第一位1的到来，当检测到第一个1后，跳转到s1，等待检测第二位1，一次类推直到跳转到s5。

具体状态解释：s0：等待检测第一个需要的序列

                        s1：已经检测到1，等待检测到第二位1

                        s2：已经检测到11，等待检测第三位0    

                        s3：已经检测到110， 等待检测第四位1

                        s4：已经检测到1101，等待检测第五位0

                        s5：已经检测到11010

        检测成功条件：状态机处于s5状态。

        在该电路中，两种状态机本质上，moore状态机是比mealy多一个s5状态，moore状态机就是通过判定是否处于该状态来判定条件是否正确，而mealy状态机则时通过s4状态以及下一个时刻的条件信号是否有效来判定条件是否正确。

2.序列检测器的verilog代码实现

2.1.mealy状态机verilog实现ssf

  1. module sequence_11010_chack (
  2. 	input 					clk							,
  3. 	input					rst_p						,
  5.     input                   sequence_num                ,
  7.     output                  num_en                      
  8. );
  9.  
  10. localparam s0   =   5'd0    ;
  11. localparam s1   =   5'd1    ;
  12. localparam s2   =   5'd2    ;
  13. localparam s3   =   5'd4    ;
  14. localparam s4   =   5'd8    ;
  15. localparam s5   =   5'd16   ;  
  16.  
  17. reg [ 4   : 0 ] cur_state   ;
  18. reg             chack_right ;
  19.  
  20. reg [ 4   : 0 ] next_state ;
  21.  
  22. //-----------------------------------------------------------------------
  23. //-----mealy状态机
  24. //---三段式实现
  25. //--序列11010检测
  26. //-----------------------------------------------------------------------
  27.  
  28. //第一段
  29. always @(posedge clk) begin
  30.     if(rst_p)
  31.         cur_state <= 5'd0 ;
  32.     else 
  33.         cur_state <= next_state ;
  34. end
  35.  
  36. //第二段
  37. always @( *) begin
  38.     case(cur_state)
  39.         s0 : next_state = (sequence_num) ? s1 : s0 ;
  40.         s1 : next_state = (sequence_num) ? s2 : s0 ;
  41.         s2 : next_state = (sequence_num) ? s2 : s3 ;
  42.         s3 : next_state = (sequence_num) ? s4 : s0 ;
  43.         s4 : next_state = (sequence_num) ? s1 : s0 ;
  44.         default : next_state = s0 ;
  45.     endcase
  46. end
  47.  
  48. //第三段
  49. always @(posedge clk) begin
  50.     if(rst_p)
  51.         chack_right <= 1'b0 ;
  52.     else begin
  53.         case(cur_state)
  54.             s4 :  chack_right <= (sequence_num) ? 1'b0 : 1'b1 ;
  55.             default : chack_right <= 1'b0 ;
  56.         endcase           
  57.     end
  58. end
  59.  
  60. assign num_en = chack_right ;

         mealy状态机输出与当前状态以及输入信号有关 可以看到代码中chack_right信号是由cur_state和sequence_num共同决定的。

2.2.moore状态机的Verilog代码实现

  1. module sequence_11010_chack (
  2. 	input 					clk							,
  3. 	input					rst_p						,
  5.     input                   sequence_num                ,
  7.     output                  num_en                      
  8. );
  9.  
  10. localparam s0   =   5'd0    ;
  11. localparam s1   =   5'd1    ;
  12. localparam s2   =   5'd2    ;
  13. localparam s3   =   5'd4    ;
  14. localparam s4   =   5'd8    ;
  15. localparam s5   =   5'd16   ;  
  16.  
  17. reg [ 4   : 0 ] cur_state   ;
  18. reg             chack_right ;
  19.  
  20. //-----------------------------------------------------------------------------
  21. //----------Moore状态机
  22. //---三段式
  23. //--序列11010检测
  24. //-----------------------------------------------------------------------------
  25. reg [ 4   : 0 ] next_state ;
  26.  
  27. //第一段
  28. always @(posedge clk) begin
  29.     if(rst_p)
  30.         cur_state <= 5'd0 ;
  31.     else 
  32.         cur_state <= next_state ;
  33. end
  34.  
  35. //第二段
  36. always @( *) begin
  37.     case(cur_state)
  38.         s0 : next_state = (sequence_num) ? s1 : s0 ;
  39.         s1 : next_state = (sequence_num) ? s2 : s0 ;
  40.         s2 : next_state = (sequence_num) ? s2 : s3 ;
  41.         s3 : next_state = (sequence_num) ? s4 : s0 ;
  42.         s4 : next_state = (sequence_num) ? s2 : s5 ;
  43.         s5 : next_state = (sequence_num) ? s1 : s0 ;
  44.         default : next_state = s0 ;
  45.     endcase
  46. end
  47.  
  48. //第三段
  49. always @(*) begin
  50.     case(cur_state)
  51.         s5 :  chack_right = 1'b1 ;
  52.         default : chack_right = 1'b0 ;
  53.     endcase           
  54. end
  55.  
  56. assign num_en = chack_right ;

        moore状态机输出只与当前状态有关，从代码中表示就是输出chack_right信号只要当cur_state处于s5就输出1，反之就输出0。

2.3.仿真代码

  1. `timescale 1ns/1ps
  2.  
  3. module sequence_11010_chack_tb;
  4.  
  5.   // Parameters
  6.  
  7.   //Ports
  8.   reg  clk=0;
  9.   reg  rst_p=1;
  10.   reg  sequence_num=0;
  11.   reg [4:0] tb_data = 5'b11010;
  12.   wire  num_en;
  13.  
  14.   sequence_11010_chack  sequence_11010_chack_inst (
  15.     .clk(clk),
  16.     .rst_p(rst_p),
  17.     .sequence_num(sequence_num),
  18.     .num_en(num_en)
  19.   );
  20.  
  21. always #5  clk = ! clk ;
  22.  
  23. initial begin
  24.     #201;
  25.     rst_p = 1'b0 ;
  26.  
  27.     //1
  28.     @(posedge clk)begin
  29.         sequence_num <= tb_data[4]  ;
  30.     end
  31.     @(posedge clk)begin
  32.         sequence_num <= tb_data[3]  ;
  33.     end
  34.     @(posedge clk)begin
  35.         sequence_num <= tb_data[2]  ;
  36.     end
  37.     @(posedge clk)begin
  38.         sequence_num <= tb_data[1]  ;
  39.     end
  40.     @(posedge clk)begin
  41.         sequence_num <= tb_data[0]  ;
  42.         tb_data <= {tb_data[3:0],tb_data[4]};
  43.     end
  44.  
  45.     //2
  46.     @(posedge clk)begin
  47.         sequence_num <= tb_data[4]  ;
  48.     end
  49.     @(posedge clk)begin
  50.         sequence_num <= tb_data[3]  ;
  51.     end
  52.     @(posedge clk)begin
  53.         sequence_num <= tb_data[2]  ;
  54.     end
  55.     @(posedge clk)begin
  56.         sequence_num <= tb_data[1]  ;
  57.     end
  58.     @(posedge clk)begin
  59.         sequence_num <= tb_data[0]  ;
  60.         tb_data <= {tb_data[3:0],tb_data[4]};
  61.     end
  62.  
  63.     //3
  64.     @(posedge clk)begin
  65.         sequence_num <= tb_data[4]  ;
  66.     end
  67.     @(posedge clk)begin
  68.         sequence_num <= tb_data[3]  ;
  69.     end
  70.     @(posedge clk)begin
  71.         sequence_num <= tb_data[2]  ;
  72.     end
  73.     @(posedge clk)begin
  74.         sequence_num <= tb_data[1]  ;
  75.     end
  76.     @(posedge clk)begin
  77.         sequence_num <= tb_data[0]  ;
  78.         tb_data <= {tb_data[3:0],tb_data[4]};
  79.     end
  80.     
  81.     //4
  82.     @(posedge clk)begin
  83.         sequence_num <= tb_data[4]  ;
  84.     end
  85.     @(posedge clk)begin
  86.         sequence_num <= tb_data[3]  ;
  87.     end
  88.     @(posedge clk)begin
  89.         sequence_num <= tb_data[2]  ;
  90.     end
  91.     @(posedge clk)begin
  92.         sequence_num <= tb_data[1]  ;
  93.     end
  94.     @(posedge clk)begin
  95.         sequence_num <= tb_data[0]  ;
  96.         tb_data <= {tb_data[3:0],tb_data[4]};
  97.     end
  98.  
  99.     //5
  100.     @(posedge clk)begin
  101.         sequence_num <= tb_data[4]  ;
  102.     end
  103.     @(posedge clk)begin
  104.         sequence_num <= tb_data[3]  ;
  105.     end
  106.     @(posedge clk)begin
  107.         sequence_num <= tb_data[2]  ;
  108.     end
  109.     @(posedge clk)begin
  110.         sequence_num <= tb_data[1]  ;
  111.     end
  112.     @(posedge clk)begin
  113.         sequence_num <= tb_data[0]  ;
  114.         tb_data <= {tb_data[3:0],tb_data[4]};
  115.     end
  116.  
  117.     //6
  118.     @(posedge clk)begin
  119.         sequence_num <= tb_data[4]  ;
  120.     end
  121.     @(posedge clk)begin
  122.         sequence_num <= tb_data[3]  ;
  123.     end
  124.     @(posedge clk)begin
  125.         sequence_num <= tb_data[2]  ;
  126.     end
  127.     @(posedge clk)begin
  128.         sequence_num <= tb_data[1]  ;
  129.     end
  130.     @(posedge clk)begin
  131.         sequence_num <= tb_data[0]  ;
  132.         tb_data <= {tb_data[3:0],tb_data[4]};
  133.     end
  134.  
  135.     //7
  136.     @(posedge clk)begin
  137.         sequence_num <= tb_data[4]  ;
  138.     end
  139.     @(posedge clk)begin
  140.         sequence_num <= tb_data[3]  ;
  141.     end
  142.     @(posedge clk)begin
  143.         sequence_num <= tb_data[2]  ;
  144.     end
  145.     @(posedge clk)begin
  146.         sequence_num <= tb_data[1]  ;
  147.     end
  148.     @(posedge clk)begin
  149.         sequence_num <= tb_data[0]  ;
  150.         tb_data <= {tb_data[3:0],tb_data[4]};
  151.     end
  152.  
  153.     //移位方向改变
  154.  
  155.     //1
  156.     @(posedge clk)begin
  157.         sequence_num <= tb_data[4]  ;
  158.     end
  159.     @(posedge clk)begin
  160.         sequence_num <= tb_data[3]  ;
  161.     end
  162.     @(posedge clk)begin
  163.         sequence_num <= tb_data[2]  ;
  164.     end
  165.     @(posedge clk)begin
  166.         sequence_num <= tb_data[1]  ;
  167.     end
  168.     @(posedge clk)begin
  169.         sequence_num <= tb_data[0]  ;
  170.         tb_data <= {tb_data[0],tb_data[4:1]};
  171.     end
  172.  
  173.     //2
  174.     @(posedge clk)begin
  175.         sequence_num <= tb_data[4]  ;
  176.     end
  177.     @(posedge clk)begin
  178.         sequence_num <= tb_data[3]  ;
  179.     end
  180.     @(posedge clk)begin
  181.         sequence_num <= tb_data[2]  ;
  182.     end
  183.     @(posedge clk)begin
  184.         sequence_num <= tb_data[1]  ;
  185.     end
  186.     @(posedge clk)begin
  187.         sequence_num <= tb_data[0]  ;
  188.         tb_data <= {tb_data[0],tb_data[4:1]};
  189.     end
  190.  
  191.     //3
  192.     @(posedge clk)begin
  193.         sequence_num <= tb_data[4]  ;
  194.     end
  195.     @(posedge clk)begin
  196.         sequence_num <= tb_data[3]  ;
  197.     end
  198.     @(posedge clk)begin
  199.         sequence_num <= tb_data[2]  ;
  200.     end
  201.     @(posedge clk)begin
  202.         sequence_num <= tb_data[1]  ;
  203.     end
  204.     @(posedge clk)begin
  205.         sequence_num <= tb_data[0]  ;
  206.         tb_data <= {tb_data[0],tb_data[4:1]};
  207.     end
  208.  
  209.     #100; 
  210.     $stop;
  211. end
  212.  
  213. endmodule

仿真结果如下：

811e7a1ca5b94302b34ff5fad50a0af7.png

 3.Reference

本文参考了csdn、知乎上相关文章。如果存在什么问题请指正！！！

完成工程和仿真代码如下链接免费下载：【免费】verilog序列检测器，序列11010，（mealy状态机和moore状态机）资源-CSDN文库

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/622327
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号