基于Verilog HDL 的数字时钟设计

基于Verilog HDL的数字时钟设计

一、实验内容：

    利用FPGA实现数字时钟设计,附带秒表功能及时间设置功能。时间设置由开关S1和S2控制，分别是增和减。开关S3是模式选择：0是正常时钟显示；1是进入调分模式；2是进入调时模式；3是进入秒表模式，当进入秒表模式时，S1具有启动和停止功能，S2具有复位归零功能。只有四位数码管，所以没有做万年历，下一步会在这个基础上加入定时闹钟。

二、实验板

自个制作的实验板，用的是Altera CycloneIII EP3C40Q240C8N。上面的这块板是简单的外围电路，有流水灯、EEPROM、蜂鸣器、MAX3232、拨码开关、开关按键。PS2解码、VGA、AD转换等外围电路正在筹划中。

 

二、实验原理图设计

1、数码管原理图：利用74HC245驱动7段共阴极数码，其中F_X是代表接入到FPGA的I/O口。

 

2、开关原理图

三、整体架构设计

1、模块结构

2、RTL Viewer

四、各个击破

第1步：数码管显示，四位数码管的a~g、dp都是复用的，得先让四位数码管能分别显示不同的数据。大家都应该想到了“同步动态扫描”。我是这样做的：每位数码工作5ms，并采取流水方式进行循环操作（列扫描），每位数码即将工作那一刻，同时给a~g送入数据，数据保留5ms并进行定时更新数据（行扫描），行与列保持同步。定时开关，定时发送数据。下图有点错误，其实是在低电平是有效的，高低电平反了。

 

第2步：小数点显示，为了与时钟显示格式更为逼真，让中间的小数点一直亮着（充分利用资源吧），其他小数点要灭掉，很不幸运，不能直接把data_dp管脚直接拉高或拉低，这里是给该管脚产生周期为20ms，占空比为3/4的一个时钟信号，下图高低电平反了。

第3步：要让不同数码显示不同数据，那么就得事先编好每位数码管要显示的数据。由于时钟与秒表显示的最大数据不一样，得单独编码，这步很简单，一看代码就知道。

 

第4步：开关的信号输入，涉及到开关，那么就得消抖。这里借鉴特权的方法实现的。

 

把要做的实验思路搞清楚后，那么数字时钟设计应该很快就会完成。

五、各模块的信号输入/输出定义

Setting.v
Pin Name	I/O	Description
clk	input	主时钟27MHZ
rst_n	input	系统复位，低有效
add_in	input	开关S1的输入
sub_in	input	开关S2的输入
model_in	input	开关S3的输入
Hour_Ten	output	时的十位
Hour_One	output	时的个位
Minute_Ten	output	分的十位
Minute_One	output	分的个位
Display_Model	output	控制时钟与秒表的显示切换
M_Start	output	启动/停止秒表计数器
M_Reset	output	复位归零

control_wei.v
Pin Name	I/O	Description
clk	input	主时钟27MHZ
rst_n	input	系统复位，低有效
select_wei	output	控制数码管流水工作

miaobiao.v
Pin Name	I/O	Description
clk	input	主时钟27MHZ
rst_n	input	系统复位，低有效
M_Start	input	启动/停止秒表计数器
M_Reset	input	复位归零
S_data1	output	秒表：第一位数码管数据编码
S_data2	output	秒表：第二位数码管数据编码
S_data3	output	秒表：第三位数码管数据编码
S_data4	output	秒表：第四位数码管数据编码

control_display.v
Pin Name	I/O	Description
clk	input	主时钟27MHZ
rst_n	input	系统复位，低有效
H_data1	input	时钟：第一位数码管数据
H_data2	input	时钟：第二位数码管数据
H_data3	input	时钟：第三位数码管数据
H_data4	input	时钟：第四位数码管数据
S_data1	input	秒表：第一位数码管数据
S_data2	input	秒表：第二位数码管数据
S_data3	input	秒表：第三位数码管数据
S_data4	input	秒表：第四位数码管数据
Display_Model	input	控制时钟与秒表的显示切换
data	output	送出7段a~g数据
data_dp	output	小数点

clock_top.v
Pin Name	I/O	Description
clk	input	主时钟27MHZ
rst_n	input	系统复位，低有效
add_in	input	开关S1的输入
sub_in	input	开关S2的输入
model_in	input	开关S3的输入
data	output	送出7段a~g数据
select_wei	output	控制数码管流水工作
data_dp	output	小数点

六：代码的实现

 control_wei.v

 /***********************************************/
 //四位数码管进行流水控制，每位数码管工作5MS
 /***********************************************/
 module control_wei(
                     clk,
                     rst_n,
                     select_wei,
                     );
 input clk;
 input rst_n;
 output[:] select_wei;

 /**********************************************/
 parameter T5MS = 'd134_999;
 /**********************************************/
 reg[:] select_wei;
 reg[:] cnt;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) cnt <= 'd0;
     else if(cnt == T5MS)
         cnt <= 'd0;
     else
         cnt <= cnt + 'b1;
 /**********************************************/
 //通过移位方式进行流水工作，定时开关
 always @(posedge clk or negedge rst_n)
     if(!rst_n) begin
         select_wei <= 'd7;
     end
     else if(cnt == T5MS) begin
         if(select_wei == 'd14)
             select_wei <= 'd7;
         else
             select_wei <= {'b1,select_wei[3:1]};
         end
 endmodule

setting.v

 module setting(
                 //input
                 clk,
                 rst_n,
                 add_in,//增加按钮
                 sub_in,//减去按钮
                 model_in,//模式选择

                 //output
                 Hour_Ten,
                 Hour_One,
                 Minute_Ten,
                 Minute_One,
                 Display_Model,
                 M_Start,
                 M_Reset,
             );
 input clk;
 input rst_n;
 input add_in;
 input sub_in;
 input model_in;

 output [:] Hour_Ten;
 output [:] Hour_One;
 output [:] Minute_Ten;
 output [:] Minute_One;
 output Display_Model;
 output M_Start;
 output M_Reset;

 /************************************/
 parameter T20MS = 'd539_999;
 parameter T1S = 'd26_999_999;
 parameter T60S = 'd1_619_999_999;
 /************************************************/
 //检测下降沿脉冲key_en = key_rst_r & (~key_rst);
 //key_rst_r要晚一个时钟节拍才能得到key_rst的值
 //key_rst在1变为0时，key_en置位
 //key_rst   1 1 0 1 1
 //key_rst_r   1 1 0 1 1
 //~key_rst  0 0 1 0 0
 //--------------------------
 //key_en    0 0 1 0 0

 //检测上升沿脉冲key_en = (~key_rst_r) & key_rst;
 //key_rst在0变为1时，key_en置位
 //key_rst       0 0 1 0 0
 //key_rst_r        0 0 1 0 0

 //key_rst       0 0 1 0 0
 //~key_rst_r        1 1 0 1 1
 //--------------------------
 //key_en        0 0 1 0 0
 /************************************************/
 reg[:] key_rst;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) key_rst <= 'b111;
     else key_rst <= {add_in,sub_in,model_in};

 reg[:] key_rst_r;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) key_rst_r <= 'b111;
     else key_rst_r <= key_rst;

 wire[:] key_en;
 assign key_en = key_rst_r & (~key_rst);
 /************************************************/
 //按键消抖动
 /************************************************/
 reg[:] cnt;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) cnt <= 'd0;
     else if(key_en) cnt <= 'd0;
     else cnt <= cnt + 'b1;
 //每隔20ms就取按键上的值
 reg[:] pin_status;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) pin_status <= 'b111;
     else if(cnt == T20MS) pin_status <= {add_in,sub_in,model_in};

 reg[:] pin_status_r;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) pin_status_r <= 'b111;
     else pin_status_r <= pin_status;
 //前20MS的值与后20MS的值
 wire[:]  pin_status_ctrl;
 assign pin_status_ctrl = pin_status_r & (~pin_status);

 /**************************************************************************************************/
 //60S计数器
 reg [:] cnt60s;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) cnt60s <= 'd0;
     else if((cnt60s == T60S) || (!isCount)) cnt60s <= 'd0;
     else if(isCount)
         cnt60s <= cnt60s + 'b1;
 /**************************************************************************************************/
 //模式控制
 //00：时钟正常跑模式
 //01：调分模式,在该模式时间计数器停止计数
 //10: 调时模式，在该模式时间计数器停止计数
 //11：秒表模式，在该模式时间计数器正常计数
 reg[:] Time_model;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) Time_model <= 'b00;
     else if(pin_status_ctrl[])
         begin
             if(Time_model == 'b11)
                 Time_model <= 'b00;
             else
             Time_model <= Time_model + 'b1;
         end

 /************************************************/
 reg Display_Model;//时钟与秒表显示
 reg isCount;//控制时间计数器
 reg M_Start;//控制秒表计数器
 reg M_Reset;//秒表复位
 reg M_flag;//开关S1按第一次代表启动，紧接在按一次代表停止
 reg [:] flag;//用来标志reg1是否到了2，到了2,reg2只能加到4
 reg [:] reg1;//时的第一位：0~2
 reg [:] reg2;//时的第二位：当第一位为0和1时，可以是0~9,当第一位为2时，只能是0~9,
 reg [:] reg3;//分的第一位：只能是0~5
 reg [:] reg4;//分的第二位：是0~9
 always @(posedge clk or negedge rst_n)
     if(!rst_n) begin
         Display_Model <= 'b0;
         isCount <= 'b0;
         M_Start <= 'b0;
         M_Reset <= 'b0;
         M_flag <= 'b0;
         reg1 <= 'd0;
         reg2 <= 'd0;
         reg3 <= 'd0;
         reg4 <= 'd0;
         flag <= 'd0;
     end
     else
         case(Time_model)
         //时钟正常开始跑
             'b00:
             begin
                 Display_Model <= 'b0;
                 isCount <= 'b1;//启动计数
                 if(cnt60s == T60S)
                 begin
                     reg4 <= reg4 + 'b1;
                     if(reg4 == 'd9)
                     begin
                         reg4 <= 'd0;
                         reg3 <= reg3 + 'b1;
                         if(reg3 == 'd5)
                         begin
                             reg3 <= 'd0;
                             if(reg1 == 'd2)
                             begin
                                 reg2 <= reg2 + 'b1;
                                 if(reg2 == 'd3)
                                 begin
                                     reg2 <= 'd0;
                                     reg1 <= 'd0;
                                 end
                             end
                             else
                             begin
                                 reg2 <= reg2 + 'b1;
                                 if(reg2 == 'd9)
                                 begin
                                 reg2 <= 'd0;
                                 reg1 <= reg1 + 'b1;
                                 end
                             end
                         end

                     end
                 end
             end

             //调分模式
             'b01:
             begin
                 isCount <= 'b1;
                 if(pin_status_ctrl[])//加
                 begin
                     reg4 <= reg4 + 'b1;
                     if(reg4 == 'd9)
                     begin
                         reg4 <= 'd0;
                         reg3 <= reg3 + 'b1;
                         if(reg3 > 'd5)
                             reg3 <= 'd0;
                     end
                 end
                 else if(pin_status_ctrl[])//减
                     begin
                         reg4 <= reg4 - 'b1;
                         if(reg4 == 'd0)
                             begin
                                 reg4 <= 'd9;
                                 reg3 <= reg3 - 'b1;
                                 if(reg3 == 'd5)
                                     reg3 <= 'd0;
                             end
                     end
             end

             //调时模式
             'b10:
             begin
                 isCount <= 'b1;
                 if(pin_status_ctrl[])//加
                 begin
                     if(flag == 'd2)
                     begin
                         reg2 <= reg2 + 'b1;
                         if(reg2 >= 'd3)
                         begin
                             reg2 <= 'd0;
                             reg1 <= 'd0;
                             flag <= 'd0;
                         end
                     end
                     else
                     begin
                         reg2 <= reg2 + 'b1;
                         if(reg2 == 'd9)
                         begin
                             flag <= flag + 'b1;
                             reg2 <= 'd0;
                             reg1 <= reg1 + 'b1;
                             if(reg1 == 'd2)
                             begin
                                 reg1 <= 'd0;
                             end
                         end
                     end
                 end
                 else if(pin_status_ctrl[])//减
                     begin
                         reg2 <= reg2 - 'b1;
                         if(reg2 == 'd0)
                             begin
                                 reg2 <= 'd9;
                                 reg1 <= reg1 - 'b1;
                                 if(reg1 == 'd2)
                                     reg1 <= 'd0;
                             end
                     end
             end    

             'b11:begin
                 isCount <= 'b1;//时间计数还得继续接着跑
                 Display_Model <= 'b1;//显示秒表
                 if(pin_status_ctrl[])//启动秒表计数
                 begin
                     if(M_flag == 'b1) begin
                         M_flag <= 'b0;
                         M_Start <= 'b0;
                     end
                     else begin
                         M_flag <= M_flag + 'b1;
                         M_Start <= 'b1;
                         M_Reset <= 'b0;

                     end
                 end
                 else if(pin_status_ctrl[])//复位并停止
                 begin
                     M_Start <= 'b0;
                     M_flag <= 'b0;
                     M_Reset <= 'b1;
                 end
             end
         endcase
 /************************************************/
 assign Hour_Ten = reg1;
 assign Hour_One = reg2;
 assign Minute_Ten = reg3;
 assign Minute_One = reg4;
 /************************************************/

 endmodule

control_data.v

 module control_data(
                     //input
                     clk,
                     rst_n,
                     Hour_Ten,
                     Hour_One,
                     Minute_Ten,
                     Minute_One,

                     //output
                     H_data1,
                     H_data2,
                     H_data3,
                     H_data4
                     );
 input clk;
 input rst_n;
 input [:] Hour_Ten;
 input [:] Hour_One;
 input [:] Minute_Ten;
 input [:] Minute_One;
 output [:] H_data1;
 output [:] H_data2;
 output [:] H_data3;
 output [:] H_data4;
 /***********************************/
 parameter     SEG_NUM0     = 'h3f,//c0,
             SEG_NUM1     = 'h06,//f9,
             SEG_NUM2     = 'h5b,//a4,
             SEG_NUM3     = 'h4f,//b0,
             SEG_NUM4     = 'h66,//99,
             SEG_NUM5     = 'h6d,//92,
             SEG_NUM6     = 'h7d,//82,
             SEG_NUM7     = 'h07,//F8,
             SEG_NUM8     = 'h7f,//80,
             SEG_NUM9     = 'h6f;//90,
 /***********************************/
 //时钟数据编码
 /***********************************/
 //数码管一要显示的列表数据（0~2）
 reg [:] data1_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         data1_temp <= 'h3f;
     else
         case(Hour_Ten)
             'd0:    data1_temp <= SEG_NUM0;
             'd1:    data1_temp <= SEG_NUM1;
             'd2:    data1_temp <= SEG_NUM2;
             default: data1_temp <= SEG_NUM0;
         endcase
 /***********************************/
 //数码管二要显示的列表数据（0~9）
 reg [:] data2_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         data2_temp <= 'h3f;
     else
         case(Hour_One)
             'd0:    data2_temp <= SEG_NUM0;
             'd1:    data2_temp <= SEG_NUM1;
             'd2:    data2_temp <= SEG_NUM2;
             'd3:    data2_temp <= SEG_NUM3;
             'd4:    data2_temp <= SEG_NUM4;
             'd5:    data2_temp <= SEG_NUM5;
             'd6:    data2_temp <= SEG_NUM6;
             'd7:    data2_temp <= SEG_NUM7;
             'd8:    data2_temp <= SEG_NUM8;
             'd9:    data2_temp <= SEG_NUM9;
             default: data2_temp <= SEG_NUM0;
         endcase
 /***********************************/
 //数码管三要显示的列表数据 (0~5)
 reg [:] data3_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         data3_temp <= 'h3f;
     else
         case(Minute_Ten)
             'd0:    data3_temp <= SEG_NUM0;
             'd1:    data3_temp <= SEG_NUM1;
             'd2:    data3_temp <= SEG_NUM2;
             'd3:    data3_temp <= SEG_NUM3;
             'd4:    data3_temp <= SEG_NUM4;
             'd5:    data3_temp <= SEG_NUM5;
             default: data3_temp <= SEG_NUM0;
         endcase
 /***********************************/
 //数码管四要显示的列表数据（1~9）
 reg [:] data4_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         data4_temp <= 'h3f;
     else
         case(Minute_One)
             'd0:    data4_temp <= SEG_NUM0;
             'd1:    data4_temp <= SEG_NUM1;
             'd2:    data4_temp <= SEG_NUM2;
             'd3:    data4_temp <= SEG_NUM3;
             'd4:    data4_temp <= SEG_NUM4;
             'd5:    data4_temp <= SEG_NUM5;
             'd6:    data4_temp <= SEG_NUM6;
             'd7:    data4_temp <= SEG_NUM7;
             'd8:    data4_temp <= SEG_NUM8;
             'd9:    data4_temp <= SEG_NUM9;
             default: data4_temp <= SEG_NUM0;
         endcase
 /*****************************************/
 assign H_data1 = data1_temp;
 assign H_data2 = data2_temp;
 assign H_data3 = data3_temp;
 assign H_data4 = data4_temp;
 /*****************************************/
 endmodule

control_display.v

 module control_display(
                         //input
                         clk,
                         rst_n,
                         H_data1,
                         H_data2,
                         H_data3,
                         H_data4,

                         S_data1,
                         S_data2,
                         S_data3,
                         S_data4,

                         Display_Model,

                         //output
                         data,
                         data_dp
                         );
 input clk;
 input rst_n;
 //时钟模式要显示数据
 input [:] H_data1;
 input [:] H_data2;
 input [:] H_data3;
 input [:] H_data4;
 //秒表模式要显示数据
 input [:] S_data1;
 input [:] S_data2;
 input [:] S_data3;
 input [:] S_data4;
 input Display_Model;//0:时钟模式，1：秒表模式

 output [:] data;//不包括小数点
 output data_dp;
 /******************************************/
 parameter T5MS = 'd134_999;
 parameter T10MS = 'd269_999;
 parameter T20MS = 'd539_999;
 /****************************************************************/
 reg [:]cnt_ms;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         cnt_ms <= 'd0;
     else if(cnt_ms == T20MS)
         cnt_ms <= 'd0;
     else
         cnt_ms <= cnt_ms + 'b1;

 /****************************************************************/
 //小数点显示
 reg [:] i;
 reg data_dp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         i <= 'd0;
     else
     case(i)
     'd0:
     if(cnt_ms != T5MS)
         data_dp = 'b0;
     else begin
         data_dp= 'b1;
         i <= i + 'b1;
     end

     'd1:
     if(cnt_ms != T10MS)
         data_dp = 'b1;
     else begin
         data_dp <= 'b0;
         i <= i + 'b1;
     end

     'd2:
     if(cnt_ms != T20MS)
         data_dp <= 'b0;
     else
         i <= 'd0;
     endcase
 /******************************************/
 //定时发送数据
 reg [:] cnt;
 reg [:] num;//每隔5MS，num加1
 always @(posedge clk or negedge rst_n)
     if(!rst_n) begin
         cnt <= 'd0;
         num <= 'd0;
     end
     else if(cnt == T5MS) begin
         num <= num + 'b1;
         cnt <= 'd0;
     end
     else
         cnt <= cnt + 'b1;
 /******************************************/
 //通过Display_Model来确定是要送秒表数据还是时钟数据
 reg [:] data_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n)
         data_temp <= 'h3f;
     else
         case(num)
             'd0:    data_temp <= Display_Model ? S_data1:H_data1;//给第一个数码管送数据
             'd1:    data_temp <= Display_Model ? S_data2:H_data2;//给第二个数码管送数据
             'd2:    data_temp <= Display_Model ? S_data3:H_data3;//给第二个数码管送数据
             'd3:    data_temp <= Display_Model ? S_data4:H_data4;//给第二个数码管送数据
         endcase
 /******************************************/
 assign data = data_temp;
 /******************************************/
 endmodule

miaobiao.v

 module miaobiao(
                     //input
                     clk,
                     rst_n,
                     M_Start,
                     M_Reset,

                     //ouput
                     S_data1,
                     S_data2,
                     S_data3,
                     S_data4
                 );
 input clk;
 input rst_n;
 input M_Start;//控制秒表计数器
 input M_Reset;//秒表复位
 output [:] S_data1;
 output [:] S_data2;
 output [:] S_data3;
 output [:] S_data4;

 /************************************************************/
 parameter     T_fenMiao     = 'd269_999;
 parameter     SEG_NUM0     = 'h3f,//c0,
             SEG_NUM1     = 'h06,//f9,
             SEG_NUM2     = 'h5b,//a4,
             SEG_NUM3     = 'h4f,//b0,
             SEG_NUM4     = 'h66,//99,
             SEG_NUM5     = 'h6d,//92,
             SEG_NUM6     = 'h7d,//82,
             SEG_NUM7     = 'h07,//F8,
             SEG_NUM8     = 'h7f,//80,
             SEG_NUM9     = 'h6f;//90,
 /************************************************************/
 //分秒计数器
 reg [:] Cnt_FenMiao;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) Cnt_FenMiao <= 'd0;
     else if((Cnt_FenMiao == T_fenMiao) || (!M_Start)) Cnt_FenMiao <= 'd0;
     else if(M_Start)
         Cnt_FenMiao <= Cnt_FenMiao + 'b1;
 /************************************************************/
 //分秒向秒进位
 reg [:] reg1;
 reg [:] reg2;
 reg [:] reg3;
 reg [:] reg4;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) begin
         reg1 <= 'd0;
         reg2 <= 'd0;
         reg3 <= 'd0;
         reg4 <= 'd0;
     end
     else if(M_Reset) begin
         reg1 <= 'd0;
         reg2 <= 'd0;
         reg3 <= 'd0;
         reg4 <= 'd0;
     end
     else if(Cnt_FenMiao == T_fenMiao)
     begin
         if(reg4 == 'd9) begin
             reg4 <= 'd0;
             if(reg3 == 'd9) begin
                 reg3 <= 'd0;
                 if(reg2 == 'd9) begin
                     reg2 <= 'd0;
                     if(reg1 == 'd5)
                         reg1 <= 'd0;
                     else reg1 <= reg1 + 'b1;
                 end
                 else
                     reg2 <= reg2 + 'b1;
             end
             else
                 reg3 <= reg3 + 'b1;
         end
         else
             reg4 <= reg4 + 'b1;
     end
 /************************************************************/
 //数据编码
 /************************************************************/
 //数码管一要显示的列表数据（0~5）
 reg [:] S_data1_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) S_data1_temp <= 'h3f;
     else
         case(reg1)
             'd0:    S_data1_temp <= SEG_NUM0;
             'd1:    S_data1_temp <= SEG_NUM1;
             'd2:    S_data1_temp <= SEG_NUM2;
             'd3:    S_data1_temp <= SEG_NUM3;
             'd4:    S_data1_temp <= SEG_NUM4;
             'd5:    S_data1_temp <= SEG_NUM5;
             default: S_data1_temp <= SEG_NUM0;
         endcase
 /***********************************/
 //数码管二要显示的列表数据（0~9）
 reg [:] S_data2_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) S_data2_temp <= 'h3f;
     else
         case(reg2)
             'd0:    S_data2_temp <= SEG_NUM0;
             'd1:    S_data2_temp <= SEG_NUM1;
             'd2:    S_data2_temp <= SEG_NUM2;
             'd3:    S_data2_temp <= SEG_NUM3;
             'd4:    S_data2_temp <= SEG_NUM4;
             'd5:    S_data2_temp <= SEG_NUM5;
             'd6:    S_data2_temp <= SEG_NUM6;
             'd7:    S_data2_temp <= SEG_NUM7;
             'd8:    S_data2_temp <= SEG_NUM8;
             'd9:    S_data2_temp <= SEG_NUM9;
             default: S_data2_temp <= SEG_NUM0;
         endcase
 /*****************************************/
 //数码管三要显示的列表数据（0~9）
 reg [:] S_data3_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) S_data3_temp <= 'h3f;
     else
         case(reg3)
             'd0:    S_data3_temp <= SEG_NUM0;
             'd1:    S_data3_temp <= SEG_NUM1;
             'd2:    S_data3_temp <= SEG_NUM2;
             'd3:    S_data3_temp <= SEG_NUM3;
             'd4:    S_data3_temp <= SEG_NUM4;
             'd5:    S_data3_temp <= SEG_NUM5;
             'd6:    S_data3_temp <= SEG_NUM6;
             'd7:    S_data3_temp <= SEG_NUM7;
             'd8:    S_data3_temp <= SEG_NUM8;
             'd9:    S_data3_temp <= SEG_NUM9;
             default: S_data3_temp <= SEG_NUM0;
         endcase
 /***********************************/
 //数码管四要显示的列表数据（0~9）
 reg [:] S_data4_temp;
 always @(posedge clk or negedge rst_n)
     if(!rst_n) S_data4_temp <= 'h3f;
     else
         case(reg4)
             'd0:    S_data4_temp <= SEG_NUM0;
             'd1:    S_data4_temp <= SEG_NUM1;
             'd2:    S_data4_temp <= SEG_NUM2;
             'd3:    S_data4_temp <= SEG_NUM3;
             'd4:    S_data4_temp <= SEG_NUM4;
             'd5:    S_data4_temp <= SEG_NUM5;
             'd6:    S_data4_temp <= SEG_NUM6;
             'd7:    S_data4_temp <= SEG_NUM7;
             'd8:    S_data4_temp <= SEG_NUM8;
             'd9:    S_data4_temp <= SEG_NUM9;
             default: S_data4_temp <= SEG_NUM0;
         endcase
 /*******************************************************/
 assign S_data1 = S_data1_temp;
 assign S_data2 = S_data2_temp;
 assign S_data3 = S_data3_temp;
 assign S_data4 = S_data4_temp;
 /*******************************************************/
 endmodule

clock_top

 module clock_top(
             //input
             clk,
             rst_n,
             add_in,
             sub_in,
             model_in,

             //output
             data,
             select_wei,
             data_dp,
            );
 input clk;
 input rst_n;
 input add_in;
 input sub_in;
 input model_in;

 output [:] data;
 output [:] select_wei;
 output data_dp;

 wire [:] Hour_Ten;
 wire [:] Hour_One;
 wire [:] Minute_Ten;
 wire [:] Minute_One;
 wire [:] H_data1,H_data2,H_data3,H_data4;
 wire [:] S_data1,S_data2,S_data3,S_data4;
 wire Display_Model;
 wire M_Start;
 wire M_Reset;

 control_wei        U1(
                     //input
                     .clk(clk),
                     .rst_n(rst_n),

                     //output
                     .select_wei(select_wei),
                     );

 setting        U2(
                 //input
                 .clk(clk),
                 .rst_n(rst_n),
                 .add_in(add_in),//增加按钮
                 .sub_in(sub_in),//减去按钮
                 .model_in(model_in),//模式选择

                 //output
                 .Hour_Ten(Hour_Ten),
                 .Hour_One(Hour_One),
                 .Minute_Ten(Minute_Ten),
                 .Minute_One(Minute_One),
                 .Display_Model(Display_Model),
                 .M_Start(M_Start),
                 .M_Reset(M_Reset),
             );

 control_data   U3(
                     //input
                     .clk(clk),
                     .rst_n(rst_n),
                     .Hour_Ten(Hour_Ten),//from to U2
                     .Hour_One(Hour_One),//from to U2
                     .Minute_Ten(Minute_Ten),//from to U2
                     .Minute_One(Minute_One),//from to U2

                     //output
                     .H_data1(H_data1),
                     .H_data2(H_data2),
                     .H_data3(H_data3),
                     .H_data4(H_data4)
                     );

 control_display     U4(
                         //input
                         .clk(clk),
                         .rst_n(rst_n),
                         .H_data1(H_data1),//from to U3
                         .H_data2(H_data2),//from to U3
                         .H_data3(H_data3),//from to U3
                         .H_data4(H_data4),//from to U3
                         .S_data1(S_data1),//from to U5
                         .S_data2(S_data2),//from to U5
                         .S_data3(S_data3),//from to U5
                         .S_data4(S_data4),//from to U5
                         .Display_Model(Display_Model),//from to U2

                         //output
                         .data(data),
                         .data_dp(data_dp)
                         );

 miaobiao         U5(
                     //input
                     .clk(clk),
                     .rst_n(rst_n),
                     .M_Start(M_Start),//from to U2
                     .M_Reset(M_Reset),//from to U2

                     //ouput
                     .S_data1(S_data1),
                     .S_data2(S_data2),
                     .S_data3(S_data3),
                     .S_data4(S_data4),
                 );
 endmodule