devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FPGA之状态机_fpga状态机的三个基本原则

作者：正经夜光杯 | 2024-08-01 19:12:02

赞

踩

fpga状态机的三个基本原则

 

状态机


 

1.状态机定义

状态机的本质就是对具有逻辑顺序和时序规律的事件的一种描述方法，它有三个要素：状态、输入、输出：状态也叫做状态变量（比如可以用电机的不同转速作为状态），输出指在某一个状态的特定输出，输入指状态机中进入每个状态的条件。

有限状态机（Finite State Machine， FSM），根据状态机的输出是否与输入有关，可分为Moore型状态机和Mealy型状态机。

Moore型状态机输出仅仅与现态有关，Mealy型状态机不仅与现态有关，也与输入有关，所以会受到输入的干扰，可能会产生毛刺（Glith）的现象，所以我们通常使用的是Moore型状态机。

Mealy型状态机：

 

Moore型状态机：

 

2.状态机描述方式

状态机描述时关键是要描述清楚几个状态机的要素，即如何进行状态转移，每个状态的输出是什么，状态转移的条件等。具体描述时方法各种各样，最常见的有三种描述方式：

一段式：整个状态机写到一个always模块里面，在该模块中既描述状态转移，又描述状态的输入和输出；

二段式：用两个always模块来描述状态机，其中一个always模块采用同步时序描述状态转移；另一个模块采用组合逻辑判断状态转移条件，描述状态转移规律以及输出；

三段式：在两个always模块描述方法基础上，使用三个always模块，一个always模块采用同步时序描述状态转移，一个always采用组合逻辑判断状态转移条件，描述状态转移规律，另一个always模块描述状态输出(可以用组合电路输出，也可以时序电路输出)。

一般而言,推荐的FSM 描述方法是后两种。这是因为：FSM和其他设计一样，最好使用同步时序方式设计，以提高设计的稳定性，消除毛刺。状态机实现后，一般来说，状态转移部分是同步时序电路而状态的转移条件的判断是组合逻辑。

 

3.不同描述方式的好坏

一段式：虽然一个always块就可以解决问题，但描述不清晰，不利于维护修改，并且不利用附加约束，不利于综合其和布局布线器对设计的优化；

二段式：第二种描述方法同第一种描述方法相比，将同步时序和组合逻辑分别放到不同的always模块中实现，这样做的好处不仅仅是便于阅读、理解、维护，更重要的是利于综合器优化代码，利于用户添加合适的时序约束条件，利于布局布线器实现设计。在第二种方式的描述中，描述当前状态的输出用组合逻辑实现，组合逻辑很容易产生毛刺，而且不利于约束，不利于综合器和布局布线器实现高性能的设计。

三段式：

  1. 第三种描述方式与第二种相比，关键在于根据状态转移规律，在上一状态根据输入条件判断出当前状态的输出，从而在不插入额外时钟节拍的前提下，实现了寄存器输出。
  2. 多了寄存器资源，却有效的避免了重大错误，这也暗示了一个数字设计里最重要的思想，中和设计思想，有的时候可以需要性能的提升，但在提升性能的同时也会增加资源占用，设计面积增大，所以两者中和往往是最优秀的设计；

 

4.状态机的优点

但是为什么要使用状态机而不使用一般时序电路呢?这是因为它具有一些一般时序电路无法比拟的优点.

  1. 用VHDL描述的状态机结构分明,易读,易懂,易排错;
  2. 相对其它时序电路而言,状态机更加稳定,运行模式类似于CPU,易于实现顺序控制等

 

5.状态机怎么叫好？

好的状态机的标准很多，最重要的几个方面如下：

  1. 状态机要安全，是指FSM不会进入死循环，特别是不会进入非预知的状态，而且由于某些扰动进入非设计状态，也能很快的恢复到正常的状态循环中来。这里 面有两层含义：其一要求该FSM的综合实现结果无毛刺等异常扰动；其二要求FSM要完备，即使受到异常扰动进入非设计状态，也能很快恢复到正常状态。
  2. 状态机的设计要满足设计的面积和速度的要求。
  3. 状态机的设计要清晰易懂、易维护。
  4.  

6.参数定义编码选择

对于格雷码和独热码，到底应该怎么选择才能达到最优综合？查阅书籍及网络资料，总结起来就是：

  1. 格雷码：适合所有状态是顺序序列，可以用格雷码来消除毛刺，但如果有复杂分支判断，则格雷码也不能达到消毛刺的目的，简单的说，格雷码适合条件不复杂，状态多的情况；
  2. 独热码：消耗较少组合逻辑，消耗更多寄存器，因此在FPGA中有利于速度和可靠性。适合条件复杂，状态少的情况。
  3. 二进制码：有过渡状态，容易跑飞。

binary和gray-code适用于触发器资源较少，组合电路资源丰富的情况（CPLD），对于FPGA，适用one-hot code。这样不但充分利用FPGA丰富的触发器资源，还因为只需比较一个bit，速度快，组合电路简单。

 

7.Example

自动售货机

一段式：

  1. module  auto_sell(
  2.     input   clk,
  3.     input       rst_n,
  4.     input       coin_one,
  5.     input       coin_half,
  6.      
  7.     output  reg     water,
  8.     output  reg     coin_back
  9. );
  10.  
  11.     parameter   ZERO        = 3'b000;
  12.     parameter   HALF        = 3'b001;
  13.     parameter   ONE         = 3'b010;
  14.     parameter   ONE_HALF = 3'b011;
  15.     parameter   TWO         = 3'b100;
  16.      
  17.     //一段式状态机
  18.     reg [2:0]       status;
  19.      
  20.     always@(posedge clk,negedge rst_n)begin
  21.         if(!rst_n)
  22.             begin
  23.                 status   <= ZERO;
  24.                 water    <= 0;
  25.                 coin_back <= 0;
  26.             end
  27.         else
  28.             case(status)
  29.                 ZERO :
  30.                         begin  
  31.                             water    <= 0;
  32.                             coin_back <= 0;
  33.                             if(coin_half)
  34.                                 status <= HALF;
  35.                             else if(coin_one)
  36.                                 status <= ONE;
  37.                             else
  38.                                 status <= status;
  39.                         end
  40.                 HALF :
  41.                         begin  
  42.                             water    <= 0;
  43.                             coin_back <= 0; 
  44.                             if(coin_half)
  45.                                 status <= ONE;
  46.                             else if(coin_one)
  47.                                 status <= ONE_HALF;
  48.                             else
  49.                                 status <= status;   
  50.                         end
  51.                 ONE :  
  52.                         begin  
  53.                             water    <= 0;
  54.                             coin_back <= 0;
  55.                             if(coin_half)
  56.                                 status <= ONE_HALF;
  57.                             else if(coin_one)
  58.                                 status <= TWO;
  59.                             else
  60.                                 status <= status;               
  61.                         end
  62.                 ONE_HALF :
  63.                             begin  
  64.                                 if(coin_half)
  65.                                     begin
  66.                                         status <= TWO;
  67.                                         water    <= 1'b0;
  68.                                         coin_back <= 1'b0;
  69.                                     end
  70.                                 else if(coin_one)
  71.                                     begin
  72.                                         status <= ZERO;
  73.                                         water    <= 1'b1;
  74.                                         coin_back <= 1'b0;
  75.                                     end
  76.                                 else
  77.                                     begin
  78.                                         status <= status;   
  79.                                         water    <= 1'b0;
  80.                                         coin_back <= 1'b0;                                      
  81.                                     end
  82.                             end
  83.                 TWO :  
  84.                         begin  
  85.                             if(coin_half)
  86.                                     begin
  87.                                         status <= ZERO;
  88.                                         water    <= 1'b1;
  89.                                         coin_back <= 1'b0;
  90.                                     end
  91.                             else if(coin_one)
  92.                                     begin
  93.                                         status <= ZERO;
  94.                                         water    <= 1'b1;
  95.                                         coin_back <= 1'b1;
  96.                                     end
  97.                             else
  98.                                     begin
  99.                                         status <= status;   
  100.                                         water    <= 1'b0;
  101.                                         coin_back <= 1'b0;                                      
  102.                                     end    
  103.                         end
  104.                 default:
  105.                             begin
  106.                                 status <= ZERO; 
  107.                                 water    <= 1'b0;
  108.                                 coin_back <= 1'b0;                                      
  109.                             end
  110.             endcase        
  111.     end
  112.  
  113. endmodule

 

二段式写法1：

  1. module  auto_sell(
  2.     input   clk,
  3.     input       rst_n,
  4.     input       coin_one,
  5.     input       coin_half,
  6.      
  7.     output  reg     water,
  8.     output  reg     coin_back
  9. );
  10.  
  11.     parameter   ZERO        = 3'b000;
  12.     parameter   HALF        = 3'b001;
  13.     parameter   ONE         = 3'b010;
  14.     parameter   ONE_HALF = 3'b011;
  15.     parameter   TWO         = 3'b100;
  16.  
  17. //--------------------二段式 1  ok--------------------------
  18.     //二段式状态机
  19.     reg [2:0]   c_status;
  20.     reg [2:0]   n_status;
  21.      
  22.     //状态转移
  23.     always@(posedge clk,negedge rst_n)begin
  24.         if(!rst_n)
  25.             c_status <= ZERO;
  26.         else
  27.             c_status <= n_status;
  28.     end
  29.      
  30.     //描述状态转移规律以及输出
  31.     always@(posedge clk,negedge rst_n)begin
  32.         if(!rst_n)
  33.             begin
  34.                 n_status <= ZERO;
  35.                 water <= 1'b0;
  36.                 coin_back <= 1'b0;  
  37.             end
  38.         else
  39.             case(c_status)
  40.                 ZERO :
  41.                         begin  
  42.                             water <= 1'b0;
  43.                             coin_back <= 1'b0;                          
  44.                             if(coin_half)
  45.                                 n_status <= HALF;
  46.                             else if(coin_one)
  47.                                 n_status <= ONE;
  48.                             else
  49.                                 n_status <= ZERO;
  50.                         end
  51.                 HALF :
  52.                         begin  
  53.                             water <= 1'b0;
  54.                             coin_back <= 1'b0;                          
  55.                             if(coin_half)
  56.                                 n_status <= ONE;
  57.                             else if(coin_one)
  58.                                 n_status <= ONE_HALF;
  59.                             else
  60.                                 n_status <= HALF;   
  61.                         end
  62.                 ONE :  
  63.                         begin  
  64.                             water <= 1'b0;
  65.                             coin_back <= 1'b0;                          
  66.                             if(coin_half)
  67.                                 n_status <= ONE_HALF;
  68.                             else if(coin_one)
  69.                                 n_status <= TWO;
  70.                             else
  71.                                 n_status <= ONE;            
  72.                         end
  73.                 ONE_HALF :
  74.                             begin  
  75.                                 water <= 1'b0;
  76.                                 coin_back <= 1'b0;                              
  77.                                 if(coin_half)
  78.                                         n_status <= TWO;
  79.                                 else if(coin_one)
  80.                                     begin
  81.                                         n_status <= ZERO;
  82.                                         water <= 1'b1;
  83.                                         coin_back <= 1'b0;  
  84.                                     end
  85.                                 else
  86.                                         n_status <= ONE_HALF;   
  87.                             end
  88.                 TWO :  
  89.                         begin  
  90.                             water <= 1'b0;
  91.                             coin_back <= 1'b0;                          
  92.                             if(coin_half)
  93.                                 begin
  94.                                     n_status <= ZERO;
  95.                                     water <= 1'b1;
  96.                                     coin_back <= 1'b0;                                      
  97.                                 end
  98.                             else if(coin_one)
  99.                                 begin
  100.                                     n_status <= ZERO;
  101.                                     water <= 1'b1;
  102.                                     coin_back <= 1'b1;                                          
  103.                                 end
  104.                             else
  105.                                 n_status <= TWO;                                        
  106.                         end
  107.                 default:
  108.                             n_status <= ZERO;                                   
  109.             endcase
  110.     end
  111.      
  112.  
  113. endmodule

二段式写法2：

  1. module  auto_sell(
  2.     input   clk,
  3.     input       rst_n,
  4.     input       coin_one,
  5.     input       coin_half,
  6.      
  7.     output  reg     water,
  8.     output  reg     coin_back
  9. );
  10.  
  11.     parameter   ZERO        = 3'b000;
  12.     parameter   HALF        = 3'b001;
  13.     parameter   ONE         = 3'b010;
  14.     parameter   ONE_HALF = 3'b011;
  15.     parameter   TWO         = 3'b100;
  16.  
  17. //---------------------二段式  2 ok--------------------------------------
  18.  
  19.     //二段式状态机
  20.     reg [2:0]   status;
  21.      
  22.     //状态转移
  23.     always@(posedge clk,negedge rst_n)begin
  24.         if(!rst_n)
  25.             status <= ZERO;
  26.         else
  27.             begin
  28.                 case(status)
  29.                     ZERO :
  30.                             begin                          
  31.                                 if(coin_half)
  32.                                     status <= HALF;
  33.                                 else if(coin_one)
  34.                                     status <= ONE;
  35.                                 else
  36.                                     status <= ZERO;
  37.                             end
  38.                     HALF :
  39.                             begin                          
  40.                                 if(coin_half)
  41.                                     status <= ONE;
  42.                                 else if(coin_one)
  43.                                     status <= ONE_HALF;
  44.                                 else
  45.                                     status <= HALF; 
  46.                             end
  47.                     ONE :  
  48.                             begin                      
  49.                                 if(coin_half)
  50.                                     status <= ONE_HALF;
  51.                                 else if(coin_one)
  52.                                     status <= TWO;
  53.                                 else
  54.                                     status <= ONE;              
  55.                             end
  56.                     ONE_HALF :
  57.                                 begin                              
  58.                                     if(coin_half)
  59.                                             status <= TWO;
  60.                                     else if(coin_one)
  61.                                         begin
  62.                                             status <= ZERO;
  63.                                         end
  64.                                     else
  65.                                             status <= ONE_HALF; 
  66.                                 end
  67.                     TWO :  
  68.                             begin                          
  69.                                 if(coin_half)
  70.                                     begin
  71.                                         status <= ZERO;                                 
  72.                                     end
  73.                                 else if(coin_one)
  74.                                     begin
  75.                                         status <= ZERO;                                     
  76.                                     end
  77.                                 else
  78.                                     status <= TWO;                                          
  79.                             end
  80.                     default:
  81.                                 status <= ZERO;                                 
  82.                 endcase        
  83.             end
  84.     end
  85.     //输出 时序逻辑
  86.     always@(posedge clk,negedge rst_n)begin
  87.         if(!rst_n)
  88.             begin
  89.                 water <= 1'b1;
  90.                 coin_back <= 1'b0;  
  91.             end
  92.         else
  93.             case(status)
  94.                 ONE_HALF:
  95.                             begin
  96.                                 if(coin_one)
  97.                                     begin
  98.                                         water <= 1'b1;
  99.                                         coin_back <= 1'b0;
  100.                                     end
  101.                                 else
  102.                                     begin
  103.                                         water <= 1'b0;
  104.                                         coin_back <= 1'b0;                              
  105.                                     end
  106.                             end
  107.                 TWO:
  108.                             begin
  109.                                 if(coin_half)
  110.                                     begin
  111.                                         water <= 1'b1;
  112.                                         coin_back <= 1'b0;
  113.                                     end
  114.                                 else if(coin_one)
  115.                                     begin
  116.                                         water <= 1'b1;
  117.                                         coin_back <= 1'b1;                              
  118.                                     end
  119.                                 else
  120.                                     begin
  121.                                         water <= 1'b0;
  122.                                         coin_back <= 1'b0;                                  
  123.                                     end
  124.                             end
  125.                 default:
  126.                             begin
  127.                                 water <= 1'b0;
  128.                                 coin_back <= 1'b0;                                  
  129.                             end        
  130.             endcase
  131.     end
  132.  
  133. endmodule

三段式：

  1. module  auto_sell(
  2.     input   clk,
  3.     input       rst_n,
  4.     input       coin_one,
  5.     input       coin_half,
  6.      
  7.     output  reg     water,
  8.     output  reg     coin_back
  9. );
  10.  
  11.     parameter   ZERO        = 3'b000;
  12.     parameter   HALF        = 3'b001;
  13.     parameter   ONE         = 3'b010;
  14.     parameter   ONE_HALF = 3'b011;
  15.     parameter   TWO         = 3'b100;
  16.  
  17.     //三段式状态机
  18.     reg [2:0]   c_status;
  19.     reg [2:0]   n_status;
  20.      
  21.     //状态转移
  22.     always@(posedge clk,negedge rst_n)begin
  23.         if(!rst_n)
  24.             c_status <= ZERO;
  25.         else
  26.             c_status <= n_status;
  27.     end
  28.      
  29.     //状态转移规律及状态输出,组合逻辑输出只与输入有关
  30.     //如果有n_status = n_status,电路会出错;
  31.     always@(*)begin
  32.         case(c_status)
  33.             ZERO :
  34.                     begin  
  35.                         if(coin_half)
  36.                             n_status = HALF;
  37.                         else if(coin_one)
  38.                             n_status = ONE;
  39.                         else
  40.                             n_status = ZERO;
  41.                     end
  42.             HALF :
  43.                     begin  
  44.                         if(coin_half)
  45.                             n_status = ONE;
  46.                         else if(coin_one)
  47.                             n_status = ONE_HALF;
  48.                         else
  49.                             n_status = HALF;   
  50.                     end
  51.             ONE :  
  52.                     begin  
  53.                         if(coin_half)
  54.                             n_status = ONE_HALF;
  55.                         else if(coin_one)
  56.                             n_status = TWO;
  57.                         else
  58.                             n_status = ONE;            
  59.                     end
  60.             ONE_HALF :
  61.                         begin  
  62.                             if(coin_half)
  63.                                 n_status = TWO;
  64.                             else if(coin_one)
  65.                                 n_status = ZERO;
  66.                             else
  67.                                 n_status = ONE_HALF;                                       
  68.                         end
  69.             TWO :  
  70.                     begin  
  71.                         if(coin_half)
  72.                             n_status = ZERO;
  73.                         else if(coin_one)
  74.                             n_status = ZERO;
  75.                         else
  76.                             n_status = TWO;        
  77.                     end
  78.             default:
  79.                         n_status = ZERO;                                   
  80.         endcase        
  81.     end
  82. always@(posedge clk,negedge rst_n)begin
  83.         if(!rst_n)
  84.             begin
  85.                 water = 1'b1;
  86.                 coin_back = 1'b0;  
  87.             end
  88.         else
  89.             case(c_status)
  90.                 ONE_HALF:
  91.                             begin
  92.                                 if(coin_one)
  93.                                     begin
  94.                                         water = 1'b1;
  95.                                         coin_back = 1'b0;
  96.                                     end
  97.                                 else
  98.                                     begin
  99.                                         water = 1'b0;
  100.                                         coin_back = 1'b0;                              
  101.                                     end
  102.                             end
  103.                 TWO:
  104.                             begin
  105.                                 if(coin_half)
  106.                                     begin
  107.                                         water = 1'b1;
  108.                                         coin_back = 1'b0;
  109.                                     end
  110.                                 else if(coin_one)
  111.                                     begin
  112.                                         water = 1'b1;
  113.                                         coin_back = 1'b1;                              
  114.                                     end
  115.                                 else
  116.                                     begin
  117.                                         water = 1'b0;
  118.                                         coin_back = 1'b0;                                  
  119.                                     end
  120.                             end
  121.                 default:
  122.                             begin
  123.                                 water = 1'b0;
  124.                                 coin_back = 1'b0;                                  
  125.                             end        
  126.             endcase
  127.     end
  128.      
  129. endmodule
  131.

 

 

 

 

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

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

  

闽ICP备14008679号