HDLBits个人刷题详解合集15-Circuits-Sequential Logic-Finite State Machines2-HDBits题目分析

最新推荐文章于 2023-01-13 12:54:29 发布

dangdang爱章鱼

最新推荐文章于 2023-01-13 12:54:29 发布

阅读量204

点赞数 1

分类专栏： Verilog代码 HDBits 文章标签： fpga开发

本文链接：https://blog.csdn.net/weixin_49100631/article/details/128612495

版权

Verilog代码同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

HDBits

19 篇文章 2 订阅

订阅专栏

有限状态机2

Exams/ece241 2013 q8

实现一个 Mealy 型有限状态机，该状态机可识别名为 x 的输入信号上的序列“101”。您的 FSM 应该有一个输出信号 z，当检测到“101”序列时，该信号被置言为 logic-1。您的 FSM 还应具有/异步复位。状态机中可能只有 3 个状态。您的 FSM 应识别重叠序列。

代码如下：

module top_module (

    input clk,

    input aresetn,    // Asynchronous active-low reset

    input x,

    output z );

// 状态定义

    parameter IDLE = 0,//0

    S1 = 1,//1

    S2 = 2;//10

    

    reg [3:0] state, next_state;

    // 组合逻辑，状态获取

    always@(*)begin

        case(state)

            IDLE: next_state = x ? S1 : IDLE;

            S1: next_state = x ? S1 : S2;

            S2: next_state = x ? S1 : IDLE;

        endcase

    end

    // 时序逻辑，状态转换

    always@(posedge clk or negedge aresetn)begin

        if(!aresetn)

            state <= IDLE;

     else

            state <= next_state;

    end

// 组合逻辑输出，通过。

    assign z = (state == S2) && x;

endmodule

Exams/ece241 2014 q5a

您将设计一个单输入一输出串行 2 的补充器摩尔状态机。输入（x）是一系列位（每个时钟周期一个），从数字的最低有效位开始，输出（Z）是输入的 2 补码。机器将接受任意长度的输入数字。电路需要异步复位。转换在释放“重置”时开始，在断言“重置”时停止。

代码如下：

module top_module (

    input clk,

    input areset,

    input x,

    output z

);

//三段式

    //状态定义

    parameter A = 2'b00,

    B = 2'b01,

    C = 2'b10,

    D = 2'b11;

    

    reg [1:0] state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk or posedge areset)begin

        if(areset)

            state <= A;

        else

            state <= next_state;

    end

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: next_state = x ? B : A;

            B: next_state = x ? D : C;

            C: next_state = x ? D : C;

            D: next_state = x ? D : C;

            default:next_state = A;

        endcase

    end

    //组合逻辑输出

    always@(*)begin

        case(state)

            A: z = 0;

            B: z = 1;

            C: z = 1;

            D: z = 0;

            default:z = 0;

        endcase

    end

endmodule

Exams/ece241 2014 q5b

下图是 2 的补充器的 Mealy 机器实现。使用独热编码实现。

代码如下：

module top_module (

    input clk,

    input areset,

    input x,

    output z

);

    //三段式

    //状态定义

    parameter A = 1'b0,

    B = 1'b1;

    reg state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk or posedge areset)begin

        if(areset)

            state <= A;

        else

            state <= next_state;

    end

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: next_state = x ? B : A;

            B: next_state = B;

            default:next_state = A;

        endcase

    end

    //组合逻辑输出

    always@(*)begin

        case(state)

            A: z = x;

            B: z = ~x;

            default:z = x;

        endcase

    end


endmodule

Exams/2014 q3fsm

考虑一个具有输入 s 和 w 的有限状态机。假设 FSM 以称为 A 的重置状态开始，如下所述。只要 s = 0，FSM 就会保持状态 A，当 s = 1 时，它就会移动到状态 B。一旦进入状态 B，FSM 将在接下来的三个中检查输入 w 的值时钟周期。如果其中两个时钟周期中的w = 1，则FSM必须在下一个时钟周期中将输出z设置为1。否则，z 必须为 0。密克罗尼西亚联邦继续检查 w 接下来的三个时钟周期，依此类推。下面的时序图说明了所需的值对于不同的 w 值，z 的。

使用尽可能少的状态。请注意，s 输入仅在状态 A 中使用，因此您只需考虑 w 输入。

代码如下：

module top_module (

    input clk,

    input reset,   // Synchronous reset

    input s,

    input w,

    output z

);

//状态定义

    parameter A = 1'b0,

    B = 1'b1;

    reg state, next_state;

    reg [1:0] ww, cnt;

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            state <= A;

        else

            state <= next_state;

    end

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            ww <= 2'b0;

        else if(state == B)

            ww <= {ww[0],w};

        else

            ww <= 2'b0;

    end

    //计数时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            cnt <= 2'd0;

        else if(state == B)

            if(cnt == 2'd2)

                cnt <= 2'd0;

         else

                cnt <= cnt + 2'd1;

        else

            cnt <= 2'd0;

    end

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: next_state = s ? B : A;

            B: next_state = B;

            default:next_state = A;

        endcase

    end

    //组合逻辑输出

    always@(posedge clk)begin

        if(reset)

            z = 1'b0;

        else if((state == B) && (cnt == 2'd2) &&

            ({ww,w} == 3'b110) | ({ww,w} == 3'b101) |

            ({ww,w} == 3'b011))

            z = 1'b1;

        else

            z = 1'b0;

    end

endmodule

Exams/2014 q3bfsm

给定如下所示的状态分配表，实现有限状态机。重置应将 FSM 重置为状态 000。

代码如下：

module top_module (

    input clk,

    input reset,   // Synchronous reset

    input x,

    output z

);

//状态定义

    parameter S0 = 3'b000,

    S1 = 3'b001,

    S2 = 3'b010,

    S3 = 3'b011,

    S4 = 3'b100;

    

    reg [2:0] state, next_state;

    

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            state <= S0;

        else

            state <= next_state;

    end

    

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            S0: next_state = x ? S1 : S0;

            S1: next_state = x ? S4 : S1;

            S2: next_state = x ? S1 : S2;

            S3: next_state = x ? S2 : S1;

            S4: next_state = x ? S4 : S3;

            default:next_state = S0;

        endcase

    end

    //组合逻辑输出

    assign z = (state == S3) | (state == S4);

endmodule

Exams/2014 q3c

给定如下所示的状态分配表，实现逻辑函数 Y[0] 和 z。

代码如下：

module top_module (

    input clk,

    input [2:0] y,

    input x,

    output Y0,

    output z

);

//状态定义

    parameter S0 = 3'b000,

    S1 = 3'b001,

    S2 = 3'b010,

    S3 = 3'b011,

    S4 = 3'b100;

    

    reg [2:0] Y;

    

    //组合逻辑，状态获取

    always@(*)begin

        case(y)

            S0: Y = x ? S1 : S0;

            S1: Y = x ? S4 : S1;

            S2: Y = x ? S1 : S2;

            S3: Y = x ? S2 : S1;

            S4: Y = x ? S4 : S3;

            default:Y = S0;

        endcase

    end

    //组合逻辑输出

    assign z = (y == S3) | (y == S4);

    assign Y0 = Y[0];

endmodule

Exams/m2014 q6b

考虑下面显示的状态机，它有一个输入 w 和一个输出 z。

假设您希望使用三个触发器和状态代码 y[3：1] = 000， 001， ...， 101 分别用于状态 A、B、...、F 来实现 FSM。显示此 FSM 的状态分配表。为触发器 y[2] 派生下一个状态表达式。

只实现 y[2] 的下一个状态逻辑。（这更像是一个FSM问题，而不是Verilog编码问题。哦，好吧。

代码如下：

module top_module (

    input [3:1] y,

    input w,

    output Y2);

//状态定义

    parameter A = 3'b000,

    B = 3'b001,

    C = 3'b010,

    D = 3'b011,

    E = 3'b100,

    F = 3'b101;

    

    reg [3:1] Y;

    

    //组合逻辑，状态获取

    always@(*)begin

        case(y)

            A: Y = w ? A : B;

            B: Y = w ? D : C;

            C: Y = w ? D : E;

            D: Y = w ? A : F;

            E: Y = w ? D : E;

            F: Y = w ? D : C;

            default:Y = A;

        endcase

    end

    //组合逻辑输出

    assign Y2 = Y[2];

endmodule

Exams/m2014 q6c

考虑下面显示的状态机，它有一个输入 w 和一个输出 z。

对于这部分，假设一个独热代码与状态赋值 'y[6：1] = 000001、000010、000100、001000、010000、100000、100000 分别用于状态 A、B,..., F。

为下一个状态信号 Y2 和 Y4 编写逻辑表达式。（通过检查推导出逻辑方程，假设是独热编码。测试平台将使用非一个热输入进行测试，以确保您不会尝试做更复杂的事情）。

代码如下：

module top_module (

    input [6:1] y,

    input w,

    output Y2,

    output Y4);

//状态定义

    parameter A = 3'b000001,

    B = 3'b000010,

    C = 3'b000100,

    D = 3'b001000,

    E = 3'b010000,

    F = 3'b100000;

    

    reg [6:1] Y;

    

    //组合逻辑，状态获取

    always@(*)begin

        case(y)

            A: Y = w ? A : B;

            B: Y = w ? D : C;

            C: Y = w ? D : E;

            D: Y = w ? A : F;

            E: Y = w ? D : E;

            F: Y = w ? D : C;

            default:Y = A;

        endcase

    end

    //组合逻辑输出

    assign Y2 = y[1]&~w;

    //Y2表示状态B，只有在状态A的情况下输入w为0的时候就可以得到Y2

    assign Y4 = y[2]&w | y[3]&w | y[5]&w | y[6]&w;

    //Y4表示状态D，可以在生成状态D的情况比较多，如示意图

endmodule

Exams/m2014 q6

考虑下面显示的状态机，它有一个输入 w 和一个输出 z。实现状态机。

代码如下；

module top_module (

    input clk,

    input reset,     // synchronous reset

    input w,

    output z);

//状态定义

    parameter A = 0,

    B = 1,

    C = 2,

    D = 3,

    E = 4,

    F = 5;

    

    reg [2:0] state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            state <= A;

        else

            state <= next_state;

    end

    

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: next_state = w ? A : B;

            B: next_state = w ? D : C;

            C: next_state = w ? D : E;

            D: next_state = w ? A : F;

            E: next_state = w ? D : E;

            F: next_state = w ? D : C;

            default:next_state = A;

        endcase

    end

    //组合逻辑输出

    assign z = (state == E || state == F);

endmodule

Exams/2012 q2fsm

请考虑下面显示的状态图。

编写表示此 FSM 的完整 Verilog 代码。对状态使用单独的always块。描述 FSM 输出，称为 z，使用连续赋值语句或始终块（由您自行决定）。分配您希望使用的任何状态代码。

代码如下;

module top_module (

    input clk,

    input reset,   // Synchronous active-high reset

    input w,

    output z

);

//状态定义

    parameter A = 0,

    B = 1,

    C = 2,

    D = 3,

    E = 4,

    F = 5;

    

    reg [2:0] state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(reset)

            state <= A;

        else

            state <= next_state;

    end

    

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: next_state = w ? B : A;

            B: next_state = w ? C : D;

            C: next_state = w ? E : D;

            D: next_state = w ? F : A;

            E: next_state = w ? E : D;

            F: next_state = w ? C : D;

            default:next_state = A;

        endcase

    end

    //组合逻辑输出

    assign z = (state == E || state == F);

endmodule

Exams/2012 q2b

下面再次显示了此问题的状态图。

假设一个独热代码与状态赋值 y[5：0] = 000001（A）， 000010（B）， 000100（C）， 001000（D）， 010000（E）， 100000（F）一起使用

为信号 Y1 编写一个逻辑表达式，它是状态触发器 y[1] 的输入。

为信号 Y3 编写一个逻辑表达式，它是状态触发器 y[3] 的输入。

（通过检查推导出逻辑方程，假设是独热编码。测试平台将使用非一个热输入进行测试，以确保您不会尝试做更复杂的事情）。

代码如下：

module top_module (

    input [5:0] y,

    input w,

    output Y1,

    output Y3

);

    assign Y1 = y[0]&w;

    assign Y3 = y[1]&~w | y[2]&~w | y[4]&~w | y[5]&~w;

endmodule

Exams/2013 q2afsm

考虑由下面所示的状态图描述的 FSM：

此 FSM 充当仲裁器电路，通过三个控制对某种类型资源的访问请求设备。每个设备通过设置信号 r[i] = 1 来请求资源，其中 r[i] 是 r[1]、r[2] 或 r[3]。每个 r[i] 是 FSM 的输入信号，代表三个设备。只要没有请求，FSM 就会保持状态 A。当一个或多个发生请求，然后 FSM 决定哪个设备获得使用该资源的授权，并且更改为将该设备的 G[i] 信号设置为 1 的状态。每个g[i]是FSM的输出。那里是一个优先级系统，因为设备 1 的优先级高于设备 2，而设备 3 具有最低优先级。因此，例如，如果设备 3 是唯一的设备，则仅当它是唯一的设备时，它才会收到授权当密克罗尼西亚联邦处于状态 A 时提出请求。一旦设备i获得FSM的授权，则只要设备的请求 r[i] = 1，设备就会继续接收授权。

编写表示此 FSM 的完整 Verilog 代码。对状态使用单独的始终块桌子和州人字拖，就像在讲座中所做的那样。描述 FSM 输出 g[i]，使用以下任一方式连续分配声明或始终阻止（由您自行决定）。分配任何状态您希望使用的代码。

代码如下：

module top_module (

    input clk,

    input resetn,    // active-low synchronous reset

    input [3:1] r,   // request

    output [3:1] g   // grant

);

    //状态定义

parameter A = 3'b000,//IDLE

    B = 3'b001,

    C = 3'b010,

    D = 3'b100;

    

    reg [2:0] state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(resetn == 0)

            state <= A;

        else

            state <= next_state;

    end

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            A: casez(r)//z表示无关项

                3'b000: next_state = A;

                3'bzz1: next_state = B;

                3'bz1z: next_state = C;

                3'b1zz: next_state = D;

                default:next_state = A;

            endcase

            B: next_state = r[1] ? B : A;

            C: next_state = r[2] ? C : A;

            D: next_state = r[3] ? D : A;

            default: next_state = A;

        endcase

    end

    //组合逻辑输出

    always@(*)begin

        g = 3'b000;

        case(state)

            B: g[1] = 1'b1;

            C: g[2] = 1'b1;

            D: g[3] = 1'b1;

        endcase

    end

endmodule

Exams/2013 q2bfsm

考虑一个用于控制某种类型电机的有限状态机。FSM 具有来自电机的输入 x 和 y，并产生控制电机的输出 f 和 g。还有一个称为clk的时钟输入和一个名为resetn的复位输入。

密克罗尼西亚联邦必须按以下方式工作。只要复位输入被置位，FSM 就会保持在开始状态，称为状态 A。当复位信号被取消置位时，则在下一个时钟之后边缘 FSM 必须在一个时钟周期内将输出 f 设置为 1。然后，FSM 必须监控 x 输入。当 x 在三个连续的时钟周期中产生值 1、0、1 时，g 应该在下一个时钟周期设置为 1。在保持g = 1的同时，FSM必须监控y输入。如果 y 的值在最多两个时钟周期内为 1，则 FSM 应保持 g = 1 永久（即，直到重置）。但是，如果 y 在两个时钟周期内没有变为 1，则 FSM 应永久设置 g = 0（直到重置）。实现有限状态机：

代码如下：

module top_module (

    input clk,

    input resetn,    // active-low synchronous reset

    input x,

    input y,

    output f,

    output g

);

    //状态定义

parameter IDLE = 4'b000,S1 = 4'b001, S2 = 4'b010,

    S3 = 4'b011, S4 = 4'b100, S5 = 4'b101,//S5为101，设置g=1

    G_HIGH = 4'd6,G_LOW = 4'd7,

    F_HIGH = 4'd8;

    

    reg [3:0] state, next_state;

    //时序逻辑，状态转换

    always@(posedge clk)begin

        if(resetn == 0)

            state <= IDLE;

        else

            state = next_state;

    end

    //组合逻辑，状态获取

    always@(*)begin

        case(state)

            IDLE: next_state = F_HIGH;//复位信号取消时，将输出f设置为1

            F_HIGH: next_state = S1;

            //接下来监控x的值，当x输入为101时，即S5状态，设置g为1

            S1: next_state = x ? S2 : S1;

            S2: next_state = x ? S2 : S3;

            S3: next_state = x ? S4 : S1;

            //监控y的值，当y在两个周期内变为1，则永久设置g=1，否则g=0

            S4: next_state = y ? G_HIGH : S5;

            S5: next_state = y ? G_HIGH : G_LOW;

            G_HIGH: next_state = G_HIGH;

            G_LOW: next_state = G_LOW;

            default: next_state = IDLE;

        endcase

    end

    //组合逻辑输出

    assign f = (state == F_HIGH);

    assign g = (state == S4 || state == S5 || state == G_HIGH);

    

endmodule

dangdang爱章鱼

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HDLBits个人刷题详解合集15-Circuits-Sequential Logic-Finite State Machines2-HDBits题目分析

HDLBits个人刷题详解合集15-Circuits-Sequential Logic-Finite State Machines2-HDBits题目分析
复制链接

扫一扫