用Verilog语言写一个数字秒表程序，测量范围为0-100s，有效数字达到0.01s，具有计时开始、计时停止和复位3种功能，测试结果用共阴极数码管显示，重要的地方写好注释

Verilog代码如下：

module stopwatch(
    input clk, // 时钟信号
    input start, // 开始计时信号
    input stop, // 停止计时信号
    input reset, // 复位信号
    output [15:0] seg // 数码管显示输出
);

reg [23:0] count; // 计数器，用于计时，精度为0.01s
reg [6:0] sec; // 秒数，用于数码管显示
reg [6:0] ten_sec; // 十位秒数，用于数码管显示
reg [6:0] min; // 分钟数，用于数码管显示
reg [6:0] ten_min; // 十位分钟数，用于数码管显示
reg [3:0] state; // 状态机状态，0表示停止计时，1表示开始计时，2表示计时中
reg [1:0] blink; // 闪烁控制，用于数码管显示

// 计时器
always @(posedge clk) begin
    if (reset) begin // 复位
        count <= 0;
        sec <= 0;
        ten_sec <= 0;
        min <= 0;
        ten_min <= 0;
        state <= 0;
        blink <= 0;
    end else begin
        case (state)
            0: begin // 停止计时
                count <= 0;
                sec <= 0;
                ten_sec <= 0;
                min <= 0;
                ten_min <= 0;
                blink <= 0;
                if (start) begin // 开始计时
                    count <= 0;
                    state <= 1;
                end
            end
            1: begin // 开始计时
                if (count >= 10000000) begin // 已经计时100s
                    state <= 0;
                    blink <= 0;
                end else if (stop) begin // 停止计时
                    state <= 0;
                    blink <= 0;
                end else begin
                    count <= count + 1;
                    state <= 2;
                end
            end
            2: begin // 计时中
                if (count >= 10000000) begin // 已经计时100s
                    state <= 0;
                    blink <= 0;
                end else if (stop) begin // 停止计时
                    state <= 0;
                    blink <= 0;
                end else if (count % 100 == 0) begin // 每隔1s更新计时
                    sec <= sec + 1;
                    if (sec == 10) begin
                        sec <= 0;
                        ten_sec <= ten_sec + 1;
                        if (ten_sec == 6) begin
                            ten_sec <= 0;
                            min <= min + 1;
                            if (min == 10) begin
                                min <= 0;
                                ten_min <= ten_min + 1;
                                if (ten_min == 6) begin
                                    ten_min <= 0;
                                end
                            end
                        end
                    end
                    blink <= ~blink;
                end else begin
                    blink <= ~blink;
                end
                count <= count + 1;
            end
        endcase
    end
end

// 数码管显示
always @(posedge clk) begin
    case (blink)
        0: seg <= {7'b1111110, 1'b0}; // 显示
        1: seg <= 16'b0; // 熄灭
    endcase
    case (state)
        0: seg <= {7'b1111111, 1'b0}; // 显示0
        1: seg <= {7'b0110111, 1'b0}; // 显示S
        2: begin // 计时中
            case (sec)
                0: seg <= {7'b1000000, 1'b0}; // 显示0
                1: seg <= {7'b1111001, 1'b0}; // 显示1
                2: seg <= {7'b0100100, 1'b0}; // 显示2
                3: seg <= {7'b0110000, 1'b0}; // 显示3
                4: seg <= {7'b0011001, 1'b0}; // 显示4
                5: seg <= {7'b0010010, 1'b0}; // 显示5
                6: seg <= {7'b0000010, 1'b0}; // 显示6
                7: seg <= {7'b1111000, 1'b0}; // 显示7
                8: seg <= {7'b0000000, 1'b0}; // 显示8
                9: seg <= {7'b0010000, 1'b0}; // 显示9
            endcase
            case (ten_sec)
                0: seg[7:1] <= {7'b1111111}; // 空位
                1: seg[7:1] <= {7'b1000000}; // 显示1
                2: seg[7:1] <= {7'b0100000}; // 显示2
                3: seg[7:1] <= {7'b0010000}; // 显示3
                4: seg[7:1] <= {7'b0001000}; // 显示4
                5: seg[7:1] <= {7'b0000100}; // 显示5
            endcase
            case (min)
                0: seg[15:8] <= {7'b1111111}; // 空位
                1: seg[15:8] <= {7'b1000000}; // 显示1
                2: seg[15:8] <= {7'b0100000}; // 显示2
                3: seg[15:8] <= {7'b0010000}; // 显示3
                4: seg[15:8] <= {7'b0001000}; // 显示4
                5: seg[15:8] <= {7'b0000100}; // 显示5
                6: seg[15:8] <= {7'b0000000}; // 显示6
                7: seg[15:8] <= {7'b1111000}; // 显示7
                8: seg[15:8] <= {7'b0000000}; // 显示8
                9: seg[15:8] <= {7'b0010000}; // 显示9
            endcase
            case (ten_min)
                0: seg[14:8] <= {7'b1111111}; // 空位
                1: seg[14:8] <= {7'b1000000}; // 显示1
                2: seg[14:8] <= {7'b0100000}; // 显示2
                3: seg[14:8] <= {7'b0010000}; // 显示3
                4: seg[14:8] <= {7'b0001000}; // 显示4
                5: seg[14:8] <= {7'b0000100}; // 显示5
            endcase
        end
    endcase
end

endmodule

说明：

1. 时钟信号 clk 为一个正脉冲，用于计时和数码管显示。
2. 开始计时信号 start 为一个高电平脉冲，用于开始计时。
3. 停止计时信号 stop 为一个高电平脉冲，用于停止计时。
4. 复位信号 reset 为一个高电平信号，用于复位计时器和数码管显示。
5. 数码管显示输出 seg 为一个16位二进制数，其中高7位用于控制数码管的显示，低9位未使用。
6. 计数器 count 用于计时，精度为0.01s。
7. 秒数 sec、十位秒数 ten_sec、分钟数 min、十位分钟数 ten_min 用于数码管显示。
8. 状态机状态 state 用于控制计时器的状态，0表示停止计时，1表示开始计时，2表示计时中。
9. 闪烁控制 blink 用于控制数码管的闪烁。

计时器部分说明：

1. 计数器 count 的精度为0.01s，因此一秒计数器需要累加100次，即 count % 100 == 0 时更新秒数。
2. 停止计时信号 stop 优先级高于计时器，即在停止计时信号 stop 的同时计时器不再累加，状态机状态变为0。
3. 计时器计时到100s后自动停止计时，状态机状态变为0。
4. 计时器复位时所有计数器清零，状态机状态变为0。

数码管显示部分说明：

1. 数码管分为4位，分别用于显示十分位、分位、十秒位、秒位。
2. 数码管的显示由状态机状态和计时器的秒数决定。
3. 当状态机状态为0时，数码管显示0；当状态机状态为1时，数码管显示S；当状态机状态为2时，数码管显示计时器的秒数。
4. 数码管的秒数部分采用BCD码显示，需要将秒数拆分为个位和十位。十位部分用高位的空位填充。
5. 数码管的显示需要进行闪烁，即每隔一段时间熄灭一次。