习题笔记 Exams/review2015 fancytimer

We want to create a timer with one input that:

1. is started when a particular input pattern (1101) is detected,
2. shifts in 4 more bits to determine the duration to delay,
3. waits for the counters to finish counting, and
4. notifies the user and waits for the user to acknowledge the timer.

The serial data is available on the data input pin. When the pattern 1101 is received, the circuit must then shift in the next 4 bits, most-significant-bit first. These 4 bits determine the duration of the timer delay. I'll refer to this as the delay[3:0].

After that, the state machine asserts its counting output to indicate it is counting. The state machine must count for exactly (delay[3:0] + 1) * 1000 clock cycles. e.g., delay=0 means count 1000 cycles, and delay=5 means count 6000 cycles. Also output the current remaining time. This should be equal to delay for 1000 cycles, then delay-1 for 1000 cycles, and so on until it is 0 for 1000 cycles. When the circuit isn't counting, the count[3:0] output is don't-care (whatever value is convenient for you to implement).

At that point, the circuit must assert done to notify the user the timer has timed out, and waits until input ack is 1 before being reset to look for the next occurrence of the start sequence (1101).

The circuit should reset into a state where it begins searching for the input sequence 1101.

Here is an example of the expected inputs and outputs. The 'x' states may be slightly confusing to read. They indicate that the FSM should not care about that particular input signal in that cycle. For example, once the 1101 and delay[3:0] have been read, the circuit no longer looks at the data input until it resumes searching after everything else is done. In this example, the circuit counts for 2000 clock cycles because the delay[3:0] value was 4'b0001. The last few cycles starts another count with delay[3:0] = 4'b1110, which will count for 15000 cycles.

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output [3:0] count,
    output counting,
    output done,
    input ack );

    parameter s0=0,s_1=1,s_11=2,s_110=3,sf_1=4,sf_2=5,sf_3=6,sf_4=7,s_count=8,s_done=9;
    reg[3:0] state,next_state;
    
    wire done_counting;
    wire shift_ena;
    wire c_in;

    reg[9:0] count_1000;
    reg[3:0] count_delay;
    reg[3:0] reg_sf;

    
    always @(posedge clk)
    begin if (reset) state <= s0;
          else state <= next_state;
    end

    always @(*)
    begin
        case(state)
        s0:    next_state = (data ? s_1:s0);  
        s_1:   next_state = (data ? s_11:s0);   //s1:1xxx
        s_11:  next_state = (data ? s_11:s_110);   //s2:11xx
        s_110: next_state = (data ? sf_1:s0);   //s3:110x
        sf_1:  next_state = sf_2;               //1101 & shift_ena=1
        sf_2:  next_state = sf_3;
        sf_3:  next_state = sf_4;
        sf_4:  next_state = s_count;     
        s_count: next_state = (done_counting ? s_done : s_count);
        s_done: next_state = (ack ? s0:s_done);

        endcase
    end 

    //reg_sf
    always @(posedge clk)
    begin if(reset) reg_sf <= 0;
          else if(shift_ena) reg_sf <= {reg_sf[2:0],data};
    end

    //1000 count
    always @(posedge clk)
    begin if(reset) count_1000 <= 999;
            else if(state==s_count) 
              begin 
                if(c_in) count_1000 <= 999;
                else count_1000 <= count_1000 - 1 ;
              end
    end

    assign c_in = (count_1000 == 0);

    //delay count
    always @(posedge clk)
      begin if (reset) count_delay <= 0;
          else if (state==sf_4) count_delay <= {reg_sf[2:0],data} ;  
          else if (c_in && count_delay ) count_delay <= count_delay-1;
      end

    assign done_counting = ((count_delay==0) & (count_1000==0));


    assign shift_ena = (state==sf_1)|(state==sf_2)|(state==sf_3)|(state==sf_4);
    assign counting = (state==s_count);
    assign done = (state==s_done);
    assign count = count_delay;



endmodule