• 【HDLBits 刷题 10】Circuits（6）Finite State Manchines 10-17

    目录

    写在前面

    Finite State Manchines

    Lemmings1

    Lemmings2

    Lemmings3

    Lemmings4

    Fsm onehot

    Fsm ps2

    Fsm ps2data

    Fsm serial

    写在前面

    HDLBits 刷题来到了最为重要的一部分---有限状态机，都说 Verilog 设计的精髓就是状态机的设计，可见状态机设计的重要性，通过三十多道的状态机的练习，可以更加熟悉状态机设计的要点，通常都设计为三段式，这样设计的状态机层次清晰且易于设计，时序上更为易懂。以下的解题方法不一定为最佳解决方案，有更好的方法欢迎提出，共同学习，共同进步！

    Finite State Manchines

    Lemmings1

    游戏 Lemmings1 涉及大脑相当简单的小动物。如此简单，以至于我们将使用有限状态机对其进行建模。

    在Lemmings  的2D世界中，Lemmings 可以处于两种状态之一：向左走或向右走。如果它撞到障碍物，它会改变方向。特别是，如果旅鼠在左侧被撞倒，它将向右走。如果它被撞到右边，它会向左走。如果它同时在两侧颠簸，它仍然会切换方向。

    实现具有两个状态、两个输入和一个输出的 Moore 状态机，以对此行为进行建模。

    以下四道题还挺有趣的，以游戏为引入，对其状态进行建模。

    44e10a32e34244deb48d256b9b9a55a8.png

    1. module top_module(
    2.     input      clk,
    3.     input      areset,    
    4.     input      bump_left,
    5.     input      bump_right,
    6.     output     walk_left,
    7.     output     walk_right
    8. );
    9.     //状态机状态定义
    10.     parameter  LEFT  = 0;
    11.     parameter  RIGHT = 1;
    12.     reg        state;
    13.     reg        next_state;
    14.  
    15. //状态机第一段，状态初始化，时序逻辑非阻塞赋值
    16. always @(posedge clk or posedge areset) begin
    17. 	if (areset) begin
    18. 		state <= LEFT;
    19. 	end
    20. 	else begin
    21. 		state <= next_state;
    22. 	end 
    23. end
    24.  
    25. //状态机第二段，状态跳转，阻塞复制
    26. always @(*) begin
    27.     next_state = state;
    28.     case(state)
    29.     	LEFT: begin
    30.     		if (bump_left) begin
    31.     			next_state = RIGHT;
    32.     		end
    33.     		else begin
    34.     			next_state = LEFT;
    35.     		end
    36.     	end
    37.     	RIGHT: begin
    38.     		if (bump_right) begin
    39.     			next_state = LEFT;
    40.     		end
    41.     		else begin
    42.     			next_state = RIGHT;
    43.     		end
    44.     	end
    45.     endcase
    46. end
    47.  
    48. //状态机第三段，结果输出，组合逻辑
    49. assign walk_left  = (state==LEFT);
    50. assign walk_right = (state==RIGHT);
    51.  
    52. endmodule

    Lemmings2

    除了左右走之外，如果地面消失在他们下面，Lemmings也会摔倒（并且大概会“啊！”）。

    除了左右走和颠簸时改变方向外，当地面=0时，旅鼠会摔倒并说“啊啊！当地面重新出现（地面=1）时，旅鼠将恢复沿与坠落前相同的方向行走。在跌倒时被撞到不会影响行走方向，并且与地面消失（但尚未下降）在同一周期中被撞击，或者当地面在仍然下降时重新出现时，也不影响行走方向。

    构建一个有限状态机来模拟这种行为。

    38adb6740e54431ca6b5d7a62d8b2492.png

    1. //`timescale 100ps / 1ps
    2. //
    3. // Stage: Finite_State_Manchines 
    4. // Engineer: LQC
    5. // Create Date: 2022/08/06
    6. // Design Name: 
    7. // Module Name: top_module
    8. // Description:    
    9. //    除了左右走之外，如果地面消失，Lemmings也会摔倒（并且大概会“啊！”）。
    10. //    
    11. //    除了左右走和颠簸时改变方向外，当地面=0时，旅鼠会摔倒并说“啊啊！
    12. //    当地面重新出现（地面=1）时，旅鼠将恢复沿与坠落前相同的方向行走。
    13. //    在跌倒时被撞到不会影响行走方向，并且与地面消失（但尚未下降）
    14. //    在同一周期中被撞击，或者当地面在仍然下降时重新出现时，也不影响行走方向。
    15. //    
    16. //    构建一个有限状态机来模拟这种行为。
    17. //
    18.  
    19. module top_module(
    20.     input        clk,
    21.     input        areset,    // Freshly brainwashed Lemmings walk left.
    22.     input        bump_left,
    23.     input        bump_right,
    24.     input        ground,
    25.     output       walk_left,
    26.     output       walk_right,
    27.     output       aaah 
    28. );
    29.  
    30.     //状态机状态定义
    31.     parameter  LEFT  = 0;
    32.     parameter  RIGHT = 1;
    33.     parameter  LEFT_AAAH = 2;
    34.     parameter  RIGHT_AAAH = 3;
    35.  
    36.     reg   [1:0]    state;
    37.     reg   [1:0]    next_state;
    38.  
    39. //状态机第一段，初始化状态，时序逻辑非阻塞赋值
    40. always @(posedge clk or posedge areset) begin
    41.  	if (areset) begin
    42.  		state <= LEFT;
    43.  	end
    44.  	else begin
    45.  		state <= next_state;
    46.  	end
    47.  end 
    48.  
    49. //状态机第二段，状态跳转，阻塞赋值
    50. always @(*) begin
    51. 	case(state)
    52. 		LEFT: begin
    53. 			if (~ground) begin
    54. 				next_state <= LEFT_AAAH;
    55. 			end
    56. 			else if (bump_left) begin
    57. 				next_state <= RIGHT;
    58. 			end
    59. 			else begin
    60. 				next_state <= LEFT;
    61. 			end
    62. 		end
    63. 		RIGHT: begin
    64. 			if (~ground) begin
    65. 				next_state <= RIGHT_AAAH;
    66. 			end
    67. 			else if (bump_right) begin
    68. 				next_state <= LEFT;
    69. 			end
    70. 			else begin
    71. 				next_state <= RIGHT;
    72. 			end
    73. 		end
    74. 		LEFT_AAAH: begin
    75. 			if (ground) begin
    76. 				next_state <= LEFT;
    77. 			end
    78. 			else begin
    79. 				next_state <= LEFT_AAAH;
    80. 			end			
    81. 		end
    82. 		RIGHT_AAAH: begin
    83. 			if (ground) begin
    84. 				next_state <= RIGHT;
    85. 			end
    86. 			else begin
    87. 				next_state <= RIGHT_AAAH;
    88. 			end		
    89. 		end
    90. 	endcase
    91. end
    92.  
    93. //状态机第三段，结果输出，组合逻辑
    94. assign walk_left  = (state==LEFT);
    95. assign walk_right = (state==RIGHT);
    96. assign aaah = ((state==LEFT_AAAH) | (state==RIGHT_AAAH));
    97.  
    98. endmodule

    Lemmings3

    除了走路和摔倒之外，Lemmings有时还可以被告知做一些有用的事情，比如挖（当dig=1时开始挖）。如果旅鼠当前在地面上行走（地面=1且未掉落），则可以挖掘，并将继续挖掘，直到到达另一侧（地面=0）。在这一点上，由于没有地面，它会掉下来（啊啊！），然后一旦它再次撞击地面，就继续朝着原来的方向走。与坠落一样，在挖掘时被撞击没有效果，并且在跌倒或没有地面时被告知要挖掘会被忽略。

    （换句话说，行走的旅鼠可能会摔倒，挖掘或改变方向。如果满足这些条件中的多个条件，则下降的优先级高于 dig，后者的优先级高于切换方向。

    扩展有限状态机以对此行为进行建模。

    7cc441f99f254abc93bd8a29ffcc15a9.png

    1. module top_module(
    2.     input       clk,
    3.     input       areset,    // Freshly brainwashed Lemmings walk left.
    4.     input       bump_left,
    5.     input       bump_right,
    6.     input       ground,
    7.     input       dig,
    8.     output      walk_left,
    9.     output      walk_right,
    10.     output      aaah,
    11.     output      digging 
    12. ); 
    13. //状态申明
    14. parameter  LEFT         =  8'b00000001;   //向左走状态
    15. parameter  RIGHT        =  8'b00000010;   //向右走状态
    16. parameter  LEFT_AH      =  8'b00000100;   //向左走出现没地喊叫
    17. parameter  RIGHT_AH     =  8'b00001000;   //向右走出现没地喊叫
    18. parameter  LEFT_DIG     =  8'b00010000;   //向左走挖掘指令
    19. parameter  RIGHT_DIG    =  8'b00100000;   //向右走挖掘指令
    20. parameter  LEFT_DIG_AH  =  8'b01000000;   //向左走挖掘出现地空
    21. parameter  RIGHT_DIG_AH =  8'b10000000;   //向右走挖掘出现地空
    22.  
    23. reg  [7:0]   state;
    24. reg  [7:0]   next_state; 
    25.  
    26. //状态机第一段，状态初始化，时序逻辑非阻塞赋值
    27. always @(posedge clk or posedge areset) begin
    28. 	if (areset) begin
    29. 		state <= LEFT;
    30. 	end
    31. 	else begin
    32. 		state <= next_state;
    33. 	end
    34. end
    35.  
    36. //状态机第二段，状态跳转，阻塞赋值
    37. always @(*) begin
    38. 	next_state = state;
    39. 	case(state)
    40. 		LEFT: begin
    41. 			if (~ground) begin
    42. 				next_state = LEFT_AH;
    43. 			end
    44. 			else if (dig) begin
    45. 				next_state = LEFT_DIG;
    46. 			end
    47. 			else if (bump_left) begin
    48. 				next_state = RIGHT;
    49. 			end
    50. 			else begin
    51. 				next_state = LEFT;
    52. 			end
    53. 		end
    54. 		RIGHT: begin
    55. 			if (~ground) begin
    56. 				next_state = RIGHT_AH;
    57. 			end
    58. 			else if (dig) begin
    59. 				next_state = RIGHT_DIG;
    60. 			end
    61. 			else if (bump_right) begin
    62. 				next_state = LEFT;
    63. 			end
    64. 			else begin
    65. 				next_state = RIGHT;
    66. 			end
    67. 		end
    68. 		LEFT_AH: begin
    69. 			if (ground) begin
    70. 				next_state = LEFT;
    71. 			end
    72. 			else begin
    73. 				next_state = LEFT_AH;
    74. 			end
    75. 		end
    76. 		RIGHT_AH: begin
    77. 			if (ground) begin
    78. 				next_state = RIGHT;
    79. 			end
    80. 			else begin
    81. 				next_state = RIGHT_AH;
    82. 			end
    83. 		end
    84. 		LEFT_DIG: begin
    85. 			if (~ground) begin
    86. 				next_state = LEFT_DIG_AH;
    87. 			end
    88. 			else begin
    89. 				next_state = LEFT_DIG;
    90. 			end
    91. 		end
    92. 		RIGHT_DIG: begin
    93. 			if (~ground) begin
    94. 				next_state = RIGHT_DIG_AH;
    95. 			end
    96. 			else begin
    97. 				next_state = RIGHT_DIG;
    98. 			end
    99. 		end
    100. 		LEFT_DIG_AH: begin
    101. 			if (ground) begin
    102. 				next_state = LEFT;
    103. 			end
    104. 			else begin
    105. 				next_state = LEFT_DIG_AH;
    106. 			end
    107. 		end
    108. 		RIGHT_DIG_AH: begin
    109. 			if (ground) begin
    110. 				next_state = RIGHT;
    111. 			end
    112. 			else begin
    113. 				next_state = RIGHT_DIG_AH;
    114. 			end
    115. 		end
    116. 		default: begin
    117. 			next_state = LEFT;
    118. 		end
    119. 	endcase
    120. end
    121.  
    122. //状态机第三段，结果输出，组合逻辑
    123. assign walk_left = (state == LEFT);
    124. assign walk_right = (state == RIGHT);
    125. assign aaah = ((state == LEFT_AH) | (state == RIGHT_AH) | (state == LEFT_DIG_AH) | (state == RIGHT_DIG_AH));
    126. assign digging = ((state == LEFT_DIG) | (state == RIGHT_DIG));
    127.  
    128. endmodule

    Lemmings4

    虽然旅鼠可以走路，摔倒和挖掘，但旅鼠并不是无懈可击的。如果旅鼠坠落太久然后撞到地面，它可能会飞溅。特别是，如果一只旅鼠坠落超过20个时钟周期，然后撞击地面，它将飞溅并停止行走，坠落或挖掘（所有4个输出变为0），永远（或直到FSM被重置）。旅鼠在落地之前可以落多远没有上限。旅鼠只在撞击地面时飞溅;它们不会在半空中飞溅。

    扩展有限状态机以对此行为进行建模。

    1f487024b9234fb68ff7dfed806bcee6.png

    1. module top_module(
    2.     input       clk,
    3.     input       areset,    // Freshly brainwashed Lemmings walk left.
    4.     input       bump_left,
    5.     input       bump_right,
    6.     input       ground,
    7.     input       dig,
    8.     output      walk_left,
    9.     output      walk_right,
    10.     output      aaah,
    11.     output      digging 
    12. ); 
    13. //状态申明
    14. parameter  LEFT         =  9'b000000001;   //向左走状态
    15. parameter  RIGHT        =  9'b000000010;   //向右走状态
    16. parameter  LEFT_AH      =  9'b000000100;   //向左走出现没地喊叫
    17. parameter  RIGHT_AH     =  9'b000001000;   //向右走出现没地喊叫
    18. parameter  LEFT_DIG     =  9'b000010000;   //向左走挖掘指令
    19. parameter  RIGHT_DIG    =  9'b000100000;   //向右走挖掘指令
    20. parameter  LEFT_DIG_AH  =  9'b001000000;   //向左走挖掘出现地空
    21. parameter  RIGHT_DIG_AH =  9'b010000000;   //向右走挖掘出现地空
    22. parameter  SPLATTER     =  9'b100000000;   //掉落时间过久碰地飞溅 
    23.  
    24. reg  [8:0]     state;
    25. reg  [8:0]     next_state; 
    26. reg  [100:0]   fall_cnt;
    27.  
    28. //状态机第一段，状态初始化，时序逻辑非阻塞赋值
    29. always @(posedge clk or posedge areset) begin
    30. 	if (areset) begin
    31. 		state <= LEFT;
    32. 	end
    33. 	else begin
    34. 		state <= next_state;
    35. 	end
    36. end
    37.  
    38. //状态机第二段，状态跳转，阻塞赋值
    39. always @(*) begin
    40. 	next_state = state;
    41. 	case(state)
    42. 		LEFT: begin
    43. 			if (~ground) begin
    44. 				next_state = LEFT_AH;
    45. 			end
    46. 			else if (dig) begin
    47. 				next_state = LEFT_DIG;
    48. 			end
    49. 			else if (bump_left) begin
    50. 				next_state = RIGHT;
    51. 			end
    52. 			else begin
    53. 				next_state = LEFT;
    54. 			end
    55. 		end
    56. 		RIGHT: begin
    57. 			if (~ground) begin
    58. 				next_state = RIGHT_AH;
    59. 			end
    60. 			else if (dig) begin
    61. 				next_state = RIGHT_DIG;
    62. 			end
    63. 			else if (bump_right) begin
    64. 				next_state = LEFT;
    65. 			end
    66. 			else begin
    67. 				next_state = RIGHT;
    68. 			end
    69. 		end
    70. 		LEFT_AH: begin
    71. 			if (ground && fall_cnt>='d20) begin
    72. 				next_state = SPLATTER;
    73. 			end
    74. 			else if (ground && fall_cnt<='d19) begin
    75. 				next_state = LEFT;
    76. 			end
    77. 			else begin
    78. 				next_state = LEFT_AH;
    79. 			end
    80. 		end
    81. 		RIGHT_AH: begin
    82. 			if (ground && fall_cnt>='d20) begin
    83. 				next_state = SPLATTER;
    84. 			end
    85. 			else if (ground && fall_cnt<='d19) begin
    86. 				next_state = RIGHT;
    87. 			end
    88. 			else begin
    89. 				next_state = RIGHT_AH;
    90. 			end
    91. 		end
    92. 		LEFT_DIG: begin
    93. 			if (~ground) begin
    94. 				next_state = LEFT_DIG_AH;
    95. 			end
    96. 			else begin
    97. 				next_state = LEFT_DIG;
    98. 			end
    99. 		end
    100. 		RIGHT_DIG: begin
    101. 			if (~ground) begin
    102. 				next_state = RIGHT_DIG_AH;
    103. 			end
    104. 			else begin
    105. 				next_state = RIGHT_DIG;
    106. 			end
    107. 		end
    108. 		LEFT_DIG_AH: begin
    109. 			if (ground && fall_cnt>='d20) begin
    110. 				next_state = SPLATTER;
    111. 			end
    112. 			else if (ground && fall_cnt<='d19) begin
    113. 				next_state = LEFT;
    114. 			end
    115. 			else begin
    116. 				next_state = LEFT_DIG_AH;
    117. 			end
    118. 		end
    119. 		RIGHT_DIG_AH: begin
    120. 			if (ground && fall_cnt>='d20) begin
    121. 				next_state = SPLATTER;
    122. 			end
    123. 			else if (ground && fall_cnt<='d19) begin
    124. 				next_state = RIGHT;
    125. 			end
    126. 			else begin
    127. 				next_state = RIGHT_DIG_AH;
    128. 			end
    129. 		end
    130. 		SPLATTER: begin
    131. 			next_state = next_state;
    132. 		end
    133. 		default: begin
    134. 			next_state = LEFT;
    135. 		end
    136. 	endcase
    137. end
    138.  
    139. //对掉落时间计数
    140. always @(posedge clk or posedge areset) begin
    141. 	if (areset) begin
    142. 		fall_cnt <= 'd0;
    143. 	end
    144. 	else if (state==LEFT_AH || state==RIGHT_AH || state==LEFT_DIG_AH || state==RIGHT_DIG_AH) begin
    145. 		fall_cnt <= fall_cnt + 'd1;
    146. 	end
    147. 	else begin
    148. 		fall_cnt <= 'd0;
    149. 	end
    150. end
    151.  
    152. //状态机第三段，结果输出，组合逻辑
    153. assign walk_left = (state == LEFT);
    154. assign walk_right = (state == RIGHT);
    155. assign aaah = ((state == LEFT_AH) | (state == RIGHT_AH) | (state == LEFT_DIG_AH) | (state == RIGHT_DIG_AH));
    156. assign digging = ((state == LEFT_DIG) | (state == RIGHT_DIG));
    157.  
    158. endmodule

    Fsm onehot

    给定具有以下具有 1 个输入和 2 个输出的状态机：

    f3c274e95be54cee9dd236ef49ff1bcc.png

    假设此状态机使用单热编码，其中状态[0]到状态[9]分别对应于状态S0到S9。除非另有说明，否则输出为零。

    实现状态机的状态转换逻辑和输出逻辑部分（但不是状态触发器）。您将获得状态为当前状态[9：0]，并且必须产生next_state[9：0]和两个输出。通过假设一个热编码的检查来推导逻辑方程。（测试平台将使用非一个热输入进行测试，以确保您不会尝试执行更复杂的操作）。

    1. module top_module(
    2.     input         in,
    3.     input  [9:0]  state,
    4.     output [9:0]  next_state,
    5.     output        out1,
    6.     output        out2
    7. );
    8.  
    9. assign next_state[0] = (state[0] & ~in) | (state[1] & ~in) | (state[2] & ~in) | (state[3] & ~in) | (state[4] & ~in) | (state[7] & ~in) | (state[8] & ~in) | (state[9] & ~in);
    10. assign next_state[1] = (state[0] & in) | (state[8] & in) | (state[9] & in);
    11. assign next_state[2] = (state[1] & in);
    12. assign next_state[3] = (state[2] & in);
    13. assign next_state[4] = (state[3] & in);
    14. assign next_state[5] = (state[4] & in);
    15. assign next_state[6] = (state[5] & in);
    16. assign next_state[7] = (state[6] & in) | (state[7] & in);
    17. assign next_state[8] = (state[5] & ~in);
    18. assign next_state[9] = (state[6] & ~in);
    19.  
    20. assign out1 = (state[8] | state[9]);
    21. assign out2 = (state[7] | state[9]);
    22.  
    23. endmodule

    Fsm ps2

    PS/2 鼠标协议发送长度为 3 个字节的消息。但是，在连续的字节流中，消息的开始和结束位置并不明显。唯一的迹象是，每个三字节消息的第一个字节总是有位[3]=1（但其他两个字节的位[3]可能是1或0，具体取决于数据）。

    我们想要一个有限状态机，当给定一个输入字节流时，它将搜索消息边界。我们将使用的算法是丢弃字节，直到我们看到一个bit[3]=1的字节。然后，我们假设这是消息的字节1，并在收到所有3个字节（完成）后发出消息接收信号。

    FSM 应在成功接收每条消息的第三个字节后立即在周期内完成信号。

    4c313525c5ce47b983bc4c8da5eba45e.png

    1. module top_module(
    2.     input        clk,
    3.     input [7:0]  in,
    4.     input        reset,    // Synchronous reset
    5.     output       done
    6. );
    7.  
    8. parameter  IDLE  = 'd0;
    9. parameter  BYTE1 = 'd1;
    10. parameter  BYTE2 = 'd2;
    11. parameter  BYTE3 = 'd3;
    12.  
    13. reg [1:0]   state;
    14. reg [1:0]   next_state;
    15.  
    16. //状态机第一段，初始状态，时序逻辑非阻塞赋值
    17. always @(posedge clk or posedge reset) begin
    18. 	if (reset) begin
    19. 		state <= IDLE;
    20. 	end
    21. 	else begin
    22. 		state <= next_state;
    23. 	end
    24. end
    25.  
    26. //状态机第二段，状态跳转，阻塞赋值
    27. always @(*) begin
    28. 	next_state = state;
    29. 	case(state)
    30. 		IDLE: begin
    31. 			if (in[3]) begin
    32. 				next_state = BYTE1;
    33. 			end
    34. 			else begin
    35. 				next_state = IDLE;
    36. 			end
    37. 		end
    38. 		BYTE1: begin
    39. 			next_state = BYTE2;
    40. 		end
    41. 		BYTE2: begin
    42. 			next_state = BYTE3;
    43. 		end
    44. 		BYTE3: begin
    45. 			if (in[3]) begin
    46. 				next_state <= BYTE1;
    47. 			end
    48. 			else begin
    49. 				next_state <= IDLE;
    50. 			end
    51. 		end
    52. 	endcase
    53. end
    54.  
    55. //状态机第三段，结果输出，组合逻辑
    56. assign done = (state == BYTE3);
    57.  
    58. endmodule

    Fsm ps2data

    现在，您已经有了一个状态机，该状态机将识别 PS/2 字节流中的三字节消息，请添加一个数据路径，该数据路径在收到数据包时也会输出 24 位（3 字节）消息（out_bytes[23：16] 是第一个字节，out_bytes[15：8] 是第二个字节，依此类推）。

    每当置位完成的信号时，out_bytes都必须有效。您可以在其他时间输出任何内容（即，不在乎）。

    例如：

    fbae3bc925114edd8aa7901bd290fccd.png

    1. module top_module(
    2.     input          clk,
    3.     input  [7:0]   in,
    4.     input          reset,
    5.     output [23:0]  out_bytes,
    6.     output         done
    7. );
    8.  
    9. parameter  IDLE  = 'd0;
    10. parameter  BYTE1 = 'd1;
    11. parameter  BYTE2 = 'd2;
    12. parameter  BYTE3 = 'd3;
    13.  
    14. reg [1:0]   state;
    15. reg [1:0]   next_state;
    16. reg [23:0]  byte_rx;
    17.  
    18. //状态机第一段，初始状态，时序逻辑非阻塞赋值
    19. always @(posedge clk) begin
    20. 	if (reset) begin
    21. 		state <= IDLE;
    22. 	end
    23. 	else begin
    24. 		state <= next_state;
    25. 	end
    26. end
    27.  
    28. //状态机第二段，状态跳转，阻塞赋值
    29. always @(*) begin
    30. 	next_state = state;
    31. 	case(state)
    32. 		IDLE: begin
    33. 			if (in[3]) begin
    34. 				next_state = BYTE1;
    35. 			end
    36. 			else begin
    37. 				next_state = IDLE;
    38. 			end
    39. 		end
    40. 		BYTE1: begin
    41. 			next_state = BYTE2;
    42. 		end
    43. 		BYTE2: begin
    44. 			next_state = BYTE3;
    45. 		end
    46. 		BYTE3: begin
    47. 			if (in[3]) begin
    48. 				next_state = BYTE1;
    49. 			end
    50. 			else begin
    51. 				next_state = IDLE;
    52. 			end
    53. 		end
    54. 	endcase
    55. end
    56.  
    57. //
    58. always @(posedge clk) begin
    59. 	if (next_state == BYTE1) begin
    60. 		byte_rx <= {byte_rx[15:0],in};
    61. 	end
    62. 	else if (next_state == BYTE2) begin
    63. 		byte_rx <= {byte_rx[15:0],in};
    64. 	end
    65. 	else if (next_state == BYTE3) begin
    66. 		byte_rx <= {byte_rx[15:0],in};;
    67. 	end
    68. 	else begin
    69. 		byte_rx <= 'd0;
    70. 	end
    71. end
    72.  
    73. //状态机第三段，结果输出，组合逻辑
    74. assign done = (state == BYTE3);
    75. assign out_bytes = byte_rx;
    76.  
    77. endmodule

    Fsm serial

    在许多（较旧的）串行通信协议中，每个数据字节都与起始位和停止位一起发送，以帮助接收方从位流中分隔字节。一种常见的方案是使用一个起始位 （0）、8 个数据位和 1 个停止位 （1）。当没有传输任何内容（空闲）时，该线也处于逻辑1。

    设计一个有限状态机，当给定比特流时，它将识别何时正确接收字节。它需要识别起始位，等待所有8个数据位，然后验证停止位是否正确。如果停止位未按预期出现，则 FSM 必须等到找到停止位后再尝试接收下一个字节。

    95accebcb00a473091dc17c1344d503b.png

    1. module top_module(
    2.     input     clk,
    3.     input     in,
    4.     input     reset,
    5.     output    done
    6. );
    7. //状态机状态申明
    8. parameter  IDLE       =  12'b000000000001; 
    9. parameter  START      =  12'b000000000010; 
    10. parameter  DATA_ONE   =  12'b000000000100; 
    11. parameter  DATA_TWO   =  12'b000000001000; 
    12. parameter  DATA_THREE =  12'b000000010000; 
    13. parameter  DATA_FOUR  =  12'b000000100000; 
    14. parameter  DATA_FIVE  =  12'b000001000000; 
    15. parameter  DATA_SIX   =  12'b000010000000; 
    16. parameter  DATA_SEVEN =  12'b000100000000; 
    17. parameter  DATA_EIGHT =  12'b001000000000; 
    18. parameter  STOP       =  12'b010000000000; 
    19. parameter  WAIT       =  12'b100000000000;
    20.  
    21. reg  [11:0]   state;
    22. reg  [11:0]   next_state;
    23.  
    24. //状态机第一段，状态初始化，时序逻辑，非阻塞赋值
    25. always @(posedge clk) begin
    26.   	if (reset) begin
    27.   		state <= IDLE;
    28.   	end
    29.   	else begin
    30.   		state <= next_state;
    31.   	end
    32. end 
    33.  
    34. //状态机第二段，状态跳转，阻塞赋值
    35. always @(*) begin
    36. 	next_state = state;
    37. 	case(state)
    38. 		IDLE: begin
    39. 			if (~in) begin
    40. 				next_state = START;
    41. 			end
    42. 			else begin
    43. 				next_state = IDLE;
    44. 			end
    45. 		end
    46. 		START: begin
    47. 			next_state = DATA_ONE;
    48. 		end
    49. 		DATA_ONE: begin
    50. 			next_state = DATA_TWO;
    51. 		end
    52. 		DATA_TWO: begin
    53. 			next_state = DATA_THREE;
    54. 		end
    55. 		DATA_THREE:begin
    56. 			next_state = DATA_FOUR;
    57. 		end
    58. 		DATA_FOUR: begin
    59. 			next_state = DATA_FIVE;
    60. 		end
    61. 		DATA_FIVE: begin
    62. 			next_state = DATA_SIX;
    63. 		end
    64. 		DATA_SIX: begin
    65. 			next_state = DATA_SEVEN;
    66. 		end
    67. 		DATA_SEVEN: begin
    68. 			next_state = DATA_EIGHT;
    69. 		end
    70. 		DATA_EIGHT: begin
    71. 			if (in) begin
    72. 				next_state = STOP;
    73. 			end
    74. 			else begin
    75. 				next_state = WAIT;
    76. 			end
    77. 		end
    78. 		WAIT: begin
    79. 			if (in) begin
    80. 				next_state = IDLE;
    81. 			end
    82. 			else begin
    83. 				next_state = WAIT;
    84. 			end
    85. 		end
    86. 		STOP: begin
    87. 			if (in) begin
    88. 				next_state = IDLE;
    89. 			end
    90. 			else begin
    91. 				next_state = START;
    92. 			end	
    93. 		end
    94. 		default: begin
    95. 			next_state = IDLE;
    96. 		end
    97. 	endcase
    98. end 
    99.  
    100. //状态机第三段，结果输出，组合逻辑
    101. assign done = (state==STOP);
    102.  
    103. endmodule

  • 相关阅读:
    渗透测试-xml注入以及xxe漏洞
    实时的语音降噪神经网络算法
    数据结构 图
    【Linux私房菜】第六期——Shell编程
    Linux：mongodb数据库源码包安装（4.4.25版本）
    【jq】如何优雅在shell脚本处理json？
    解决ubuntu22.04共享文件夹问题
    PMP每日一练 | 考试不迷路-8.5（包含敏捷+多选）
    6.27 JAVA笔试题
    C++空间配置器
  • 原文地址：https://blog.csdn.net/m0_61298445/article/details/126368390