Caso práctico: entrenador de tiempo de reacción con ULX3S

/*
 * Module: reaction_trainer
 * Description: A hardware reaction time measurement tool for the Radiona ULX3S.
 */
module reaction_trainer #(
    parameter MS_TICKS = 25000,      // 25MHz clock: 25,000 ticks = 1ms
    parameter DEBOUNCE_TICKS = 250000 // 10ms debounce
)(
    input  wire clk_25mhz,
    input  wire btn_start,
    input  wire btn_react,
    output reg  [7:0] led
);

    // --- State Machine Definitions ---
    localparam S_IDLE   = 3'd0;
    localparam S_WAIT   = 3'd1;
    localparam S_TEST   = 3'd2;
    localparam S_RESULT = 3'd3;
    localparam S_FAULT  = 3'd4;

    reg [2:0] state = S_IDLE;

    // --- Button Debouncing ---
    reg [17:0] debounce_counter_start = 0;
    reg [17:0] debounce_counter_react = 0;
    reg start_clean = 0;
    reg react_clean = 0;
    reg start_sync_1 = 0, start_sync_2 = 0;
    reg react_sync_1 = 0, react_sync_2 = 0;

    always @(posedge clk_25mhz) begin
        // Double-flop synchronizers
        start_sync_1 <= btn_start; start_sync_2 <= start_sync_1;
        react_sync_1 <= btn_react; react_sync_2 <= react_sync_1;

        // Debounce btn_start
        if (start_sync_2 == start_clean) begin
            debounce_counter_start <= 0;
        end else begin
            debounce_counter_start <= debounce_counter_start + 1;
            if (debounce_counter_start >= DEBOUNCE_TICKS) begin
                start_clean <= start_sync_2;
                debounce_counter_start <= 0;
            end
        end

        // Debounce btn_react
        if (react_sync_2 == react_clean) begin
            debounce_counter_react <= 0;
        end else begin
            debounce_counter_react <= debounce_counter_react + 1;
            if (debounce_counter_react >= DEBOUNCE_TICKS) begin
                react_clean <= react_sync_2;
                debounce_counter_react <= 0;
            end
        end
    end

    // Edge detection for debounced buttons
    reg start_clean_last = 0;
    reg react_clean_last = 0;
    wire start_pressed = (start_clean && !start_clean_last);
    wire react_pressed = (react_clean && !react_clean_last);

    always @(posedge clk_25mhz) begin
        start_clean_last <= start_clean;
        react_clean_last <= react_clean;
    end

    // --- Timers and LFSR ---
    reg [15:0] ms_counter = 0;
    reg [15:0] timer_ms = 0;
    reg [15:0] random_wait_ms = 0;

    // 16-bit LFSR for pseudo-randomness
    reg [15:0] lfsr = 16'hACE1;

    always @(posedge clk_25mhz) begin
        // Continuously run LFSR to ensure entropy based on human timing
        lfsr <= {lfsr[14:0], lfsr[15] ^ lfsr[13] ^ lfsr[12] ^ lfsr[10]};
    end

    // --- Main FSM ---
    reg [24:0] blink_counter = 0; // For visual effects in IDLE/FAULT

    always @(posedge clk_25mhz) begin
        blink_counter <= blink_counter + 1;

        // Millisecond tick generator
        if (ms_counter >= MS_TICKS - 1) begin
            ms_counter <= 0;
            if (state == S_WAIT || state == S_TEST) begin
                timer_ms <= timer_ms + 1;
            end
        end else begin
            ms_counter <= ms_counter + 1;
        end

        case (state)
            S_IDLE: begin
                // Alternating outer LEDs to show IDLE
                led <= blink_counter[23] ? 8'b10000001 : 8'b01000010;
                if (start_pressed) begin
                    // Calculate wait time: 1000 ms + random (0 to 2047 ms)
                    random_wait_ms <= 1000 + (lfsr & 16'h07FF);
                    timer_ms <= 0;
                    ms_counter <= 0;
                    state <= S_WAIT;
                end
            end

            S_WAIT: begin
                led <= 8'b00000000; // All LEDs off during wait
                if (react_pressed) begin
                    // False start!
                    state <= S_FAULT;
                end else if (timer_ms >= random_wait_ms) begin
                    timer_ms <= 0;
                    state <= S_TEST;
                end
            end

            S_TEST: begin
                led <= 8'b11111111; // GO signal!
                if (react_pressed) begin
                    state <= S_RESULT;
                end else if (timer_ms > 5000) begin
                    // Timeout after 5 seconds
                    state <= S_IDLE;
                end
            end

            S_RESULT: begin
                // Display bar graph based on reaction time (timer_ms)
                // <150ms: 1 LED, 150-199: 2 LEDs, 200-249: 3 LEDs... >450ms: 8 LEDs
                if (timer_ms < 150)       led <= 8'b00000001;
                else if (timer_ms < 200)  led <= 8'b00000011;
                else if (timer_ms < 250)  led <= 8'b00000111;
                else if (timer_ms < 300)  led <= 8'b00001111;
                else if (timer_ms < 350)  led <= 8'b00011111;
                else if (timer_ms < 400)  led <= 8'b00111111;
                else if (timer_ms < 450)  led <= 8'b01111111;
                else                      led <= 8'b11111111;

                if (start_pressed) begin
                    state <= S_IDLE;
                end
            end

            S_FAULT: begin
                // Fast blink all LEDs to indicate false start
                led <= blink_counter[22] ? 8'b11111111 : 8'b00000000;
                if (start_pressed) begin
                    state <= S_IDLE;
                end
            end

            default: state <= S_IDLE;
        endcase
    end

endmodule

`timescale 1ns/1ps

module reaction_trainer_tb;

    reg clk;
    reg btn_start;
    reg btn_react;
    wire [7:0] led;

    // Instantiate the Device Under Test (DUT)
    // Override parameters to speed up simulation drastically
    reaction_trainer #(
        .MS_TICKS(2),      // 2 ticks = 1 "ms" for simulation
        .DEBOUNCE_TICKS(5) // 5 ticks for debounce
    ) dut (
        .clk_25mhz(clk),
        .btn_start(btn_start),
        .btn_react(btn_react),
        .led(led)
    );

    // Generate simulated clock
    initial begin
        clk = 0;
        forever #20 clk = ~clk; // 40ns period -> 25MHz
    end

    initial begin
        $dumpfile("reaction_trainer.vcd");
        $dumpvars(0, reaction_trainer_tb);

        // Initialize inputs
        btn_start = 0;
        btn_react = 0;

        // Wait a few cycles in IDLE
        #1000;

        // Press START button
        $display("[%0t] Pressing START button...", $time);
        btn_start = 1;
        #500;
        btn_start = 0;

        // Wait for LED to turn on (TEST state)
        $display("[%0t] Waiting for GO signal...", $time);
        wait(led == 8'b11111111);
        $display("[%0t] LED is ON! Reacting...", $time);

        // Simulate a fast reaction time (e.g., 180ms)
        // In this TB, 1ms = 2 ticks = 80ns. So 180ms = 14400ns.
        #14400;
        btn_react = 1;
        #500;
        btn_react = 0;

        // Wait for RESULT state to settle
        #5000;
        $display("[%0t] Simulation complete. LED output: %b", $time, led);
        $finish;
    end

endmodule