用Verilog设计一个电子秒表包括顶层模块，时钟模块，按键消抖模块，技术控制模块，译码显示模块

好的，这里是一个简单的Verilog秒表设计，包括顶层模块、时钟模块、按键消抖模块、技术控制模块和译码显示模块。

顶层模块：

module stopwatch(
    input wire clk, // 时钟信号
    input wire reset, // 复位信号
    input wire start_stop, // 开始/停止信号
    input wire clear, // 清零信号
    output reg [3:0] sec, // 秒数输出
    output reg [3:0] min, // 分钟数输出
    output reg [3:0] hour // 小时数输出
    );

    wire clk_1Hz; // 1Hz时钟信号
    wire clk_10Hz; // 10Hz时钟信号
    wire debounced_start_stop; // 按键消抖后的开始/停止信号
    wire debounced_clear; // 按键消抖后的清零信号
    wire control_start; // 技术控制模块的开始信号
    wire control_clear; // 技术控制模块的清零信号
    wire [2:0] display_data; // 译码显示模块的输出数据

    // 实例化时钟模块
    clk_divider divider(
        .clk(clk),
        .reset(reset),
        .clk_1Hz(clk_1Hz),
        .clk_10Hz(clk_10Hz)
    );

    // 实例化按键消抖模块
    debounce debouncer(
        .clk(clk),
        .reset(reset),
        .input(start_stop),
        .debounced_output(debounced_start_stop)
    );
    debounce debouncer_clear(
        .clk(clk),
        .reset(reset),
        .input(clear),
        .debounced_output(debounced_clear)
    );

    // 实例化技术控制模块
    control controller(
        .start_stop(debounced_start_stop),
        .clear(debounced_clear),
        .clk_10Hz(clk_10Hz),
        .control_start(control_start),
        .control_clear(control_clear)
    );

    // 实例化译码显示模块
    decoder display(
        .data(display_data),
        .seg(sec),
        .seg(min),
        .seg(hour)
    );

    // 实例化计数器模块
    counter stopwatch(
        .clk_10Hz(clk_10Hz),
        .reset(control_clear),
        .start(control_start),
        .sec(sec),
        .min(min),
        .hour(hour)
    );

endmodule

时钟模块：

module clk_divider(
    input wire clk, // 时钟信号
    input wire reset, // 复位信号
    output reg clk_1Hz, // 1Hz时钟信号
    output reg clk_10Hz // 10Hz时钟信号
    );

    reg [23:0] count = 0; // 计数器

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            count <= 0;
            clk_1Hz <= 0;
            clk_10Hz <= 0;
        end else begin
            count <= count + 1;
            if (count == 23999999) begin // 1s
                count <= 0;
                clk_1Hz <= ~clk_1Hz;
            end else if (count == 2399999) begin // 10ms
                clk_10Hz <= ~clk_10Hz;
            end
        end
    end

endmodule

按键消抖模块：

module debounce(
    input wire clk, // 时钟信号
    input wire reset, // 复位信号
    input wire input, // 输入信号
    output reg debounced_output // 消抖后的输出信号
    );

    reg [1:0] count = 0; // 计数器
    reg [1:0] input_history = 0; // 输入历史记录

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            count <= 0;
            input_history <= 0;
            debounced_output <= 0;
        end else begin
            count <= count + 1;
            input_history <= {input_history[0], input};
            if (count == 2) begin
                count <= 0;
                if (input_history == 3'b111) begin
                    debounced_output <= 1;
                end else if (input_history == 3'b000) begin
                    debounced_output <= 0;
                end
            end
        end
    end

endmodule

技术控制模块：

module control(
    input wire start_stop, // 开始/停止信号
    input wire clear, // 清零信号
    input wire clk_10Hz, // 10Hz时钟信号
    output reg control_start, // 技术控制模块的开始信号
    output reg control_clear // 技术控制模块的清零信号
    );

    reg [1:0] state = 0; // 状态机状态
    reg [3:0] count_sec = 0; // 秒数计数器
    reg [3:0] count_min = 0; // 分钟数计数器
    reg [3:0] count_hour = 0; // 小时数计数器

    always @(posedge clk_10Hz) begin
        case (state)
            2'b00: begin // 初始状态
                control_start <= 0;
                control_clear <= 0;
                if (start_stop) begin
                    count_sec <= 0;
                    count_min <= 0;
                    count_hour <= 0;
                    state <= 2'b01;
                end else if (clear) begin
                    state <= 2'b10;
                end
            end
            2'b01: begin // 计数状态
                control_start <= 1;
                control_clear <= 0;
                count_sec <= count_sec + 1;
                if (count_sec == 10) begin
                    count_sec <= 0;
                    count_min <= count_min + 1;
                    if (count_min == 10) begin
                        count_min <= 0;
                        count_hour <= count_hour + 1;
                        if (count_hour == 10) begin
                            count_hour <= 0;
                        end
                    end
                end
                if (~start_stop) begin
                    state <= 2'b00;
                end else if (clear) begin
                    state <= 2'b10;
                end
            end
            2'b10: begin // 清零状态
                control_start <= 0;
                control_clear <= 1;
                count_sec <= 0;
                count_min <= 0;
                count_hour <= 0;
                if (~clear) begin
                    state <= 2'b00;
                end
            end
        endcase
    end

endmodule

译码显示模块：

module decoder(
    input wire [2:0] data, // 输入数据
    output reg [6:0] seg_sec, // 秒数译码输出
    output reg [6:0] seg_min, // 分钟数译码输出
    output reg [6:0] seg_hour // 小时数译码输出
    );

    wire [6:0] code [9:0];

    assign code[0] = 7'b0000001; // 0
    assign code[1] = 7'b1001111; // 1
    assign code[2] = 7'b0010010; // 2
    assign code[3] = 7'b0000110; // 3
    assign code[4] = 7'b1001100; // 4
    assign code[5] = 7'b0100100; // 5
    assign code[6] = 7'b0100000; // 6
    assign code[7] = 7'b0001111; // 7
    assign code[8] = 7'b0000000; // 8
    assign code[9] = 7'b0000100; // 9

    always @(*) begin
        case (data[0])
            3'b000: seg_sec <= code[data[1]];
            3'b001: seg_min <= code[data[1]];
            3'b010: seg_hour <= code[data[1]];
        endcase
    end

endmodule

计数器模块：

module counter(
    input wire clk_10Hz, // 10Hz时钟信号
    input wire reset, // 复位信号
    input wire start, // 开始信号
    output reg [3:0] sec, // 秒数输出
    output reg [3:0] min, // 分钟数输出
    output reg [3:0] hour // 小时数输出
    );

    reg [3:0] count_sec = 0; // 秒数计数器
    reg [3:0] count_min = 0; // 分钟数计数器
    reg [3:0] count_hour = 0; // 小时数计数器

    always @(posedge clk_10Hz or posedge reset) begin
        if (reset) begin
            count_sec <= 0;
            count_min <= 0;
            count_hour <= 0;
            sec <= 0;
            min <= 0;
            hour <= 0;
        end else if (start) begin
            count_sec <= count_sec + 1;
            if (count_sec == 10) begin
                count_sec <= 0;
                count_min <= count_min + 1;
                if (count_min == 10) begin
                    count_min <= 0;
                    count_hour <= count_hour + 1;
                    if (count_hour == 10) begin
                        count_hour <= 0;
                    end
                end
            end
        end
    end

    assign sec = count_sec;
    assign min = count_min;
    assign hour = count_hour;

endmodule

注意，这只是一个简单的秒表设计，还有很多可以改进和优化的地方，例如添加报警功能、显示毫秒数等。