FPGA基础——序列识别器（FSM）

(1)

我们想要创建一个计时器:

1. 在检测到特定模式(1101)时启动，
2. 再移动4位来确定延迟时间，
3. 等计数器数完，然后
4. 通知用户并等待用户确认计时器。

在这个问题中，只实现控制计时器的有限状态机。这里不包括数据路径(计数器和一些比较器)。

 

串行数据在数据输入引脚上可用。当接收到模式1101时，状态机必须断言输出shift_ena为4个时钟周期。

 

在此之后，状态机将断言其计数输出，以表明它正在等待计数器，并等待输入done_count达到最大值。

 

此时，状态机必须断言done，以通知用户计时器超时，并等待直到输入ack为1，然后重置，以寻找下一个启动序列(1101)的出现。

 

状态机应该重新设置为开始搜索输入序列1101的状态。

 

下面是预期输入和输出的示例。“x”状态可能会让人读起来有点困惑。它们表明FSM不应该关心这个周期中特定的输入信号。例如，一旦检测到1101模式，FSM就不再查看输入的数据，直到它在其他所有事情都完成之后继续搜索。

其状态转移图如下：

 

 

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output shift_ena,
    output counting,
    input done_counting,
    output done,
    input ack );
    parameter S=4'd0,S1=4'd1,S11=4'd2,S110=4'd3;
    parameter B0=4'd4,B1=4'd5,B2=4'd6,B3=4'd7;
    parameter Count=4'd8,Wait=4'd9;
    reg [3:0] state,next;
    
    always@(posedge clk)
        if(reset)
            state <= S;
        else
            state <= next;
    
    always@(*)begin
        case(state)
            S:
                next <= data?S1:S;
            S1:
                next <= data?S11:S;
            S11:
                next <= data?S11:S110;
            S110:
                next <= data?B0:S;
            B0:
                next <= B1;
            B1:
                next <= B2;
            B2:
                next <= B3;
            B3:
                next <= Count;
            Count:
                next <= done_counting?Wait:Count;
            Wait:
                next <= ack?S:Wait;
            default:
                next <= S;
        endcase
    end
    
    assign shift_ena = (state==B0 || state==B1 || state==B2 || state==B3);
    assign counting = state==Count;
    assign done = state==Wait;   
    
endmodule

 (2)

串行数据在数据输入引脚上可用。当模式1101被接收时，电路必须在接下来的4位中移位，最有效位先移位。这4位决定定时器延迟的持续时间。我把这称为延迟[3:0]。

在此之后，状态机将断言其计数输出，以表明它正在计数。状态机必须精确计算(delay[3:0] + 1) * 1000个时钟周期。例如，delay=0表示计数1000个周期，delay=5表示计数6000个周期。也输出当前剩余时间。这应该等于延迟1000个循环，然后延迟-1为1000个循环，以此类推，直到它为0为1000个循环。当电路不计数时，count[3:0]输出是不关心的(任何值方便你实现)。

在这一点上，电路必须断言done以通知用户计时器超时，并等待直到输入ack为1才被重置，以寻找下一个开始序列(1101)的出现。

电路应复位到开始寻找输入序列1101的状态。

下面是预期输入和输出的示例。“x”状态可能会让人读起来有点困惑。它们表明FSM不应该关心这个周期中特定的输入信号。例如，一旦1101和delay[3:0]被读取，电路就不再查看输入的数据，直到它在其他所有事情都完成之后恢复搜索。在这个例子中，电路计数2000个时钟周期，因为延迟[3:0]值是4'b0001。最后几个周期开始另一个计数，延时[3:0]= 4'b1110，计数为15000个周期。

 

 

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output [3:0] count,
    output counting,
    output done,
    input ack );
    
    parameter S=4'd0,S1=4'd1,S11=4'd2,S110=4'd3;
    parameter B0=4'd4,B1=4'd5,B2=4'd6,B3=4'd7;
    parameter Count=4'd8,Wait=4'd9;
    reg [3:0] state,next;
    reg [3:0] delay;
    reg [3:0] a;
    reg [15:0]    counter;
    wire done_counting;
    
    always@(posedge clk)
        if(reset)
            state <= S;
        else
            state <= next;
    
    always@(posedge clk)
        if(reset)
            counter <= 0;
        else if(next==Wait)
            counter <= 0;
           else if(next==Count)
            counter <= counter+1'b1;
    
    always@(*)begin
        if(counter <= 1000)begin
            a = 4'd0;
        end
        else if(counter > 1000 && counter <= 2000)begin
            a = 4'd1;
        end
        else if(counter > 2000 && counter <= 3000)begin
            a = 4'd2;
        end
        else if(counter > 3000 && counter <= 4000)begin
            a = 4'd3;
        end
        else if(counter > 4000 && counter <= 5000)begin
            a = 4'd4;
        end
        else if(counter > 5000 && counter <= 6000)begin
            a = 4'd5;
        end
        else if(counter > 6000 && counter <= 7000)begin
            a = 4'd6;
        end
        else if(counter > 7000 && counter <= 8000)begin
            a = 4'd7;
        end
        else if(counter > 8000 && counter <= 9000)begin
            a = 4'd8;
        end
        else if(counter > 9000 && counter <= 10000)begin
            a = 4'd9;
        end
        else if(counter > 10000 && counter <= 11000)begin
            a = 4'd10;
        end
        else if(counter > 11000 && counter <= 12000)begin
            a = 4'd11;
        end
        else if(counter > 12000 && counter <= 13000)begin
            a = 4'd12;
        end
        else if(counter > 13000 && counter <= 14000)begin
            a = 4'd13;
        end
        else if(counter > 14000 && counter <= 15000)begin
            a = 4'd14;
        end
        else begin
            a = 4'd15;
        end
    end 
    
    always@(*)begin
        case(state)
            S:
                next <= data?S1:S;
            S1:
                next <= data?S11:S;
            S11:
                next <= data?S11:S110;
            S110:
                next <= data?B0:S;
            B0:begin
                next <= B1;
                delay[3] <= data;
            end
            B1:begin
                next <= B2;
                delay[2] <= data;
            end
            B2:begin
                next <= B3;
                delay[1] <= data;
            end
            B3:begin
                next <= Count;
                delay[0] <= data;
            end
            Count:
                next <= done_counting?Wait:Count;
            Wait:
                next <= ack?S:Wait;
            default:
                next <= S;
        endcase
    end
    
    assign done_counting = (counter==(delay+1)*1000)?1'b1:1'b0;
    assign count = (state == Count) ? delay-a : 0;
    assign counting = state==Count;
    assign done = state==Wait;   
    
endmodule