至简设计系列_闹钟

最新推荐文章于 2023-05-30 21:23:02 发布
最新推荐文章于 2023-05-30 21:23:02 发布
阅读量709 收藏 8
点赞数
分类专栏： FPGA 文章标签： fpga verilog 闹钟 案例
原文链接：http://www.fpgabbs.cn/forum.php?mod=viewthread&tid=1054&fromuid=100105
版权

–作者：小黑同学

本文为明德扬原创及录用文章，转载请注明出处！

1.1.1 概述

数字时钟是采用数字电路技术实现时、分、秒计时显示的装置，可以用数字同时显示时，分，秒的精确时间并实现准确校时，具备体积小、重量轻、抗干扰能力强、对环境要求高、高精确性、容易开发等特性，在工业控制系统、智能化仪器表、办公自动化系统等诸多领域取得了极为广泛的应用，诸如自动报警、按时自动打铃、时间程序自动控制、定时广播、自定启闭路灯、定时开关烘箱、通断动力设备、甚至各种定时电器的自动启用等。与传统表盘式机械时钟相比，数字时钟具有更高的准确性和直观性，由于没有机械装置，其使用寿命更长。

1.1.2 设计目标

设计一款具有闹钟功能的数字时钟，具体要求如下

1、 用8个数码管实现，四个一组，每组有分钟和秒。左边一组是时间显示，右边一组用来做闹钟时间。

2、 当左边时间等于右边时，蜂鸣器响5秒。

3、 闹钟时间和显示时间均可通过3个按键设置。设置方法：按下按键1，时钟暂停，跳到设置时间状态，再按下按键1，回到正常状态。通过按键2，选择要设置的位置，初始设置秒个位，按一下，设置秒十位，再按下，设置分个位，以此类推，循环设置。通过按键3，设置数值，按一下数值加1，如果溢出则重新变为0。

1.1.3 系统结构框图

系统结构框图如下所示：

结构图共分两个，如果使用的开发板上是矩阵键盘的时候，对应的结构图是图一。如果使用的开发板上是普通按键的时候，对应的结构图是图二。
在这里插入图片描述

图一
在这里插入图片描述

图二

1.1.4模块功能

Ø 按键检测模块实现功能

1、将外来异步信号打两拍处理，将异步信号同步化。

2、实现20ms按键消抖功能，并输出有效按键信号。

Ø 矩阵键盘模块实现功能

1、将外来异步信号打两拍处理，将异步信号同步化。

2、实现20ms按键消抖功能。

3、实现矩阵键盘的按键检测功能，并输出有效按键信号。

Ø 时间产生模块实现功能

1、 产生显示时间数据。

2、 产生闹钟时间数据，

3、根据接收到的不同的按键信号，产生暂停、开启、设置时间的功能。

Ø 数码管显示模块实现功能

1、 对接收到的时间数据进行译码。

Ø 蜂鸣器模块实现功能

1、 将接受到的显示时间数据与闹钟时间数据进行比较，控制蜂鸣器的开启。

1.1.5顶层信号

信号名接口方向定义
clk输入系统时钟，50Mhz
rst_n输入低电平复位信号
Key输入3位按键信号，开发板按键为矩阵键盘时，不需要该信号
Key_col输入4位矩阵键盘列信号，默认高电平，开发板按键为普通按键时，不需要该信号
Key_row输出4位矩阵键盘行信号，默认低电平，开发板按键为普通按键时，不需要该信号
Segment输出8位数码管段选信号
Seg_sel输出8位数码管位选信号
beep输出1位蜂鸣器控制信号

1.1.6参考代码

下面是使用普通按键的顶层代码：

module alarm_clock(
 clk       ,  
 rst_n     ,  
 key       ,  
 segment   ,  
 seg_sel   ,  
 beep  
);

input clk ;

input rst_n ;

input [2:0 ] key ;

output [7:0 ] segment ;

output [7:0 ] seg_sel ;

output beep ;

wire [7:0 ] segment ;

wire [7:0 ] seg_sel ;

wire beep ;

wire [3:0 ] xs_sec_low ;

wire [3:0 ] xs_sec_high ;

wire [3:0 ] xs_min_low ;

wire [3:0 ] xs_min_high ;

wire [3:0 ] sec_low ;

wire [3:0 ] sec_high ;

wire [3:0 ] min_low ;

wire [3:0 ] min_high ;

wire [25:0] counter ;

wire [3:0 ] key_vld ;

wire flag_set
;

key_module u0(
         .clk         (clk         ),  
         .rst_n       (rst_n       ),  
         .key_in      (key         ),  
         .key_vld     (key_vld     )  
         );  
         
time_data u1(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .key_vld     (key_vld     ),   
         .flag_set   (flag_set ),

         .counter     (counter     ),  
         .sec_low     (sec_low     ),  
         .sec_high    (sec_high    ),  
         .min_low     (min_low     ),  
         .min_high    (min_high    ),  
         .xs_sec_low  (xs_sec_low  ),   
         .xs_sec_high (xs_sec_high ),   
         .xs_min_low  (xs_min_low  ),   
         .xs_min_high (xs_min_high )   
         );  
         
beep u2(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .flag_set  (flag_set ),

         .counter     (counter     ),   
         .beep        (beep        ),  
         .sec_low     (sec_low     ),  
         .sec_high    (sec_high    ),  
         .min_low     (min_low     ),  
         .min_high    (min_high    ),  
         .xs_sec_low  (xs_sec_low  ),  
         .xs_sec_high (xs_sec_high ),  
         .xs_min_low  (xs_min_low  ),  
         .xs_min_high (xs_min_high )   
         );  
         
seg_disp u3(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .segment_data({xs_min_high,xs_min_low,xs_sec_high,xs_sec_low,min_high,min_low,sec_high,sec_low}),   
         .segment     (segment     ),   
         .seg_sel     (seg_sel     )    
);

endmodule

下面是使用矩阵键盘的顶层代码：

module alarm_clock_jvzhen(
 clk       ,  
 rst_n     ,  
 key_col   ,  
 key_row   ,  
 segment   ,  
 seg_sel   ,  
 beep  
);

input clk ;

input rst_n ;

input [3:0 ] key_col ;

output [3:0 ] key_row ;

output [7:0 ] segment ;

output [7:0 ] seg_sel ;

output beep ;

wire [7:0 ] segment ;

wire [7:0 ] seg_sel ;

wire beep ;

wire [3:0 ] xs_sec_low ;

wire [3:0 ] xs_sec_high ;

wire [3:0 ] xs_min_low ;

wire [3:0 ] xs_min_high ;

wire [3:0 ] sec_low ;

wire [3:0 ] sec_high ;

wire [3:0 ] min_low ;

wire [3:0 ] min_high ;

wire [25:0] counter ;

wire [3:0 ] key_vld ;

wire flag_set;

wire [15:0] key_out ;

key_scan u0(
         .clk         (clk         ),  
         .rst_n       (rst_n       ),  
         .key_col     (key_col     ),  
         .key_row     (key_row     ),  
         .key_en      (key_vld     )  
         );  
         
time_data u1(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .key_vld     (key_vld     ),   
         .flag_set  (flag_set ),

         .counter     (counter     ),  
         .sec_low     (sec_low     ),  
         .sec_high    (sec_high    ),  
         .min_low     (min_low     ),  
         .min_high    (min_high    ),  
         .xs_sec_low  (xs_sec_low  ),   
         .xs_sec_high (xs_sec_high ),   
         .xs_min_low  (xs_min_low  ),   
         .xs_min_high (xs_min_high )   
         );  
         
beep u2(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .flag_set (flag_set ),

         .counter     (counter     ),   
         .beep        (beep        ),  
         .sec_low     (sec_low     ),  
         .sec_high    (sec_high    ),  
         .min_low     (min_low     ),  
         .min_high    (min_high    ),  
         .xs_sec_low  (xs_sec_low  ),  
         .xs_sec_high (xs_sec_high ),  
         .xs_min_low  (xs_min_low  ),  
         .xs_min_high (xs_min_high )   
         );  
         
seg_disp u3(
         .clk         (clk         ),   
         .rst_n       (rst_n       ),   
         .segment_data({xs_min_high,xs_min_low,xs_sec_high,xs_sec_low,min_high,min_low,sec_high,sec_low}),   
         .segment     (segment     ),   
         .seg_sel     (seg_sel     )    
);

endmodule

1.2 按键检测模块设计

1.2.1 接口信号

信号接口方向定义
clk输入系统时钟
rst_n输入低电平复位信号
key_in输入按键输入
key_vld输出按键按下指示信号

1.2.2 设计思路

在前面的案例中已经有按键检测的介绍，所以这里不在过多介绍，详细介绍请看下方链接：

【每周FPGA案例】至简设计系列_按键控制数字时钟

1.2.3参考代码

使用明德扬的计数器模板，可以很快速很熟练地写出按键消抖模块。

always @(posedge clk or negedge rst_n)begin
 if(rst_n==1'b0)begin  
     cnt <= 20'b0;  
 end  
 else if(add_cnt)begin  
     if(end_cnt)  
         cnt <= 20'b0;  
     else  
         cnt <= cnt + 1'b1;  
end  
else begin  
    cnt <= 0;  
end  
end

assign add_cnt = flag_add1’b0 && (&key_in_ff10);
assign end_cnt = add_cnt && cnt == TIME_20MS - 1;

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    flag_add <= 1'b0;  
end  
else if(end_cnt)begin  
    flag_add <= 1'b1;  
end  
else if(&key_in_ff1==1)begin  
    flag_add <= 1'b0;  
end  
end

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_in_ff0 <= {{KEY_W}{1'b1}};  
    key_in_ff1 <= {{KEY_W}{1'b1}};  
end  
else begin  
    key_in_ff0 <= key_in    ;  
    key_in_ff1 <= key_in_ff0;  
end  
end

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_vld <= 0;  
end  
else if(end_cnt)begin  
    key_vld <= ~key_in_ff1;  
end  
else begin  
    key_vld <= 0;  
end  
end

1.3 矩阵键盘模块设计

1.3.1接口信号

信号接口方向定义
clk输入系统时钟
rst_n输入低电平复位信号
key_col输入矩阵键盘列输入信号
Key_row输出矩阵键盘行输出信号
Key_en输出按键按下指示信号

1.3.2 设计思路

在前面的案例中已经有矩阵键盘的介绍，所以这里不在过多介绍，详细介绍请看下方链接：

1.3.3参考代码

always @(posedge clk or negedge rst_n)begin
 if(rst_n==1'b0)begin  
     key_col_ff0 <= 4'b1111;  
     key_col_ff1 <= 4'b1111;  
 end  
 else begin  
     key_col_ff0 <= key_col    ;  
     key_col_ff1 <= key_col_ff0;  
 end  
end

always @(posedge clk or negedge rst_n) begin
if (rst_n==0) begin  
    shake_cnt <= 0;   
end  
else if(add_shake_cnt) begin  
    if(end_shake_cnt)  
        shake_cnt <= 0;   
    else  
        shake_cnt <= shake_cnt+1 ;  
end
end

assign add_shake_cnt = key_col_ff1!=4’hf;
assign end_shake_cnt = add_shake_cnt && shake_cnt == TIME_20MS-1 ;

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    state_c <= CHK_COL;  
end  
else begin  
    state_c <= state_n;  
end  
end

always @(*)begin
case(state_c)  
    CHK_COL: begin  
                 if(col2row_start )begin  
                     state_n = CHK_ROW;  
                 end  
                 else begin  
                     state_n = CHK_COL;  
                 end  
             end  
    CHK_ROW: begin  
                 if(row2del_start)begin  
                     state_n = DELAY;  
                 end  
                 else begin  
                     state_n = CHK_ROW;  
                 end  
             end  
    DELAY :  begin  
                 if(del2wait_start)begin  
                     state_n = WAIT_END;  
                 end  
                 else begin  
                     state_n = DELAY;  
                 end  
             end  
    WAIT_END: begin  
                 if(wait2col_start)begin  
                     state_n = CHK_COL;  
                 end  
                 else begin  
                     state_n = WAIT_END;  
                 end  
              end  
   default: state_n = CHK_COL;  
endcase  
end

assign col2row_start = state_c==CHK_COL && end_shake_cnt;
assign row2del_start = state_cCHK_ROW && row_index3 && end_row_cnt;
assign del2wait_start= state_c==DELAY && end_row_cnt;
assign wait2col_start= state_cWAIT_END && key_col_ff14’hf;

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_row <= 4'b0;  
end  
else if(state_c==CHK_ROW)begin  
    key_row <= ~(1'b1 << row_index);  
end  
else begin  
    key_row <= 4'b0;  
end  
end

always @(posedge clk or negedge rst_n) begin
if (rst_n==0) begin  
    row_index <= 0;   
end  
else if(add_row_index) begin  
    if(end_row_index)  
        row_index <= 0;   
    else  
        row_index <= row_index+1 ;  
end
else if(state_c!=CHK_ROW)begin
   row_index <= 0;  
end
end

assign add_row_index = state_c==CHK_ROW && end_row_cnt;
assign end_row_index = add_row_index && row_index == 4-1 ;

always @(posedge clk or negedge rst_n) begin
if (rst_n==0) begin  
    row_cnt <= 0;   
end  
else if(add_row_cnt) begin  
    if(end_row_cnt)  
        row_cnt <= 0;   
    else  
        row_cnt <= row_cnt+1 ;  
end
end

assign add_row_cnt = state_cCHK_ROW || state_cDELAY;
assign end_row_cnt = add_row_cnt && row_cnt == 16-1 ;

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_col_get <= 0;  
end  
else if(state_c==CHK_COL && end_shake_cnt ) begin  
    if(key_col_ff1==4'b1110)  
        key_col_get <= 0;  
    else if(key_col_ff1==4'b1101)  
        key_col_get <= 1;  
    else if(key_col_ff1==4'b1011)  
        key_col_get <= 2;  
    else   
        key_col_get <= 3;  
end  
end

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_out <= 0;  
end  
else if(state_c==CHK_ROW && end_row_cnt)begin  
    key_out <= {row_index,key_col_get};  
end  
else begin  
    key_out <= 0;  
end  
end

always @(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin  
    key_vld <= 1'b0;  
end  
else if(state_c==CHK_ROW && end_row_cnt && key_col_ff1[key_col_get]==1'b0)begin  
    key_vld <= 1'b1;  
end  
else begin  
    key_vld <= 1'b0;  
end  
end

always @(*)begin
if(rst_n==1'b0)begin  
    key_en = 0;  
end  
else if(key_vld && key_out==0)begin  
    key_en = 4'b0001;  
end  
else if(key_vld && key_out==1)begin  
    key_en = 4'b0010;  
end  
else if(key_vld && key_out==2)begin  
    key_en = 4'b0100;  
end  
else begin  
    key_en = 0;  
end  
end

1.4 时间产生模块设计

1.4.1接口信号

信号接口方向定义
clk输入系统时钟
rst_n输入低电平复位信号
key_vld输入按键按下指示信号
end_counter输出时钟计数器结束条件，表示1秒的时间
Xs_sec_low输出显示的秒低位计数器
Xs_sec_high输出显示的秒高位计数器
Xs_min_low输出显示的分低位计数器
Xs_min_high输出显示的分高位计数器
Sec_low输出闹钟的秒低位计数器
Sec_high输出闹钟的秒高位计数器
Min_low输出闹钟的分低位计数器
Min_high输出闹钟的分高位计数器
Flag_set输出设置状态指示信号

1.4.2设计思路

根据题目功能要求可知，要显示的时间就是在完整的数字时钟的基础上，减少了时的高位和低位的显示，再介绍架构之前，先了解一下本模块其他几个信号的作用。

设置状态指示信号flag_set：该信号初始状态为低电平，表示模块处于正常工作状态，当按下按键key1时，设置状态指示信号进行翻转，变为高电平，表示进入到设置状态。

设置位计数器sel_cnt：该计数器表示要设置的位，初始状态为0，表示可以设置闹钟的秒低位，当其为1时表示可以设置闹钟的秒的高位，按照这样的顺序依次类推，当其为7的时候，表示可以设置显示时间的分高位。加一条件为key_vld[1]==1’b1，表示按下按键key2的时候加一；结束条件为8，显示时间的四个数码管加上闹钟的四个数码管共8个，所以数8个就清零。

由此可提出5个计数器的架构，如下图所示：
在这里插入图片描述
该架构由5个计数器组成：时钟计数器counter、秒低位计数器xs_sec_low、秒高位计数器xs_sec_high、分低位计数器xs_min_low、分高位计数器xs_min_high。

时钟计数器counter：用于计算1秒的时钟个数，加一条件为flag_set==1’b0，表示刚上电时开始计数，key1按下之后，进入设置模式，停止计数，再按下又重新开始计数；结束条件为50000000，表示数到1秒就清零。

秒低位计数器xs_sec_low：用于对1秒进行计数，加一条件为(sel_cnt==5-1
&& set_en) || end_counter，表示在设置状态下可通过按键key3来控制加一，或者在正常状态时数到1秒就加1；结束条件为10，表示数到10秒就清零。

秒高位计数器xs_sec_high：用于对10秒进行计数，加一条件为(sel_cnt==6-1
&& set_en) || end_xs_sec_low，表示在设置状态下可通过按键key3来控制加一，或者在正常状态时数到10秒就加1；结束条件为6，表示数到60秒就清零。

分低位计数器xs_min_low：用于对1分进行计数，加一条件为(sel_cnt==7-1
&& set_en) || end_xs_sec_high，表示在设置状态下可通过按键key3来控制加一，或者在正常状态时数到1分就加1；结束条件为10，表示数到10分就清零。

分高位计数器xs_min_high：用于对10分进行计数，加一条件为(sel_cnt==8-1
&& set_en) || end_xs_min_low，表示在设置状态下可通过按键key3来控制加一，或者在正常状态时数到10分就加1；结束条件为6，表示数到60分就清零。

上面介绍了显示时间的计数器架构，下面我们来思考一下闹钟部分的架构。

我们都知道闹钟的工作原理，它本身不会自动计数，需要我们手动设置。根据本设计的功能要求，有四个数码管来显示设置的闹钟秒的高低位和分的高低位，因此我们提出四个计数器组成的架构，这四个计数器相互独立，互不干涉，结构图如下：
在这里插入图片描述

该架构由4个计数器组成：秒低位计数器sec_low、秒高位计数器sec_high、分低位计数器min_low、分高位计数器min_high。

秒低位计数器sec_low：用于对闹钟秒的低位进行计数，加一条件为sel_cnt==1-1 && set_en，表示在设置状态下通过按键key3来控制加一 ；结束条件为10，表示最大能设置为9，超过之后便清零。

秒高位计数器sec_high：用于对闹钟秒的高位进行计数，加一条件为sel_cnt==2-1 && set_en，表示在设置状态下可通过按键key3来控制加一；结束条件为6，表示最大能设置为5，超过之后便清零。

分低位计数器min_low：用于对闹钟分的低位进行计数，加一条件为sel_cnt==3-1 && set_en，表示在设置状态下可通过按键key3来控制加一；结束条件为10，表示最大能设置为9，超过之后便清零。

分高位计数器min_high：用于对闹钟分高位进行计数，加一条件为sel_cnt==4-1 && set_en，表示在设置状态下可通过按键key3来控制加一；结束条件为6，表示最大能设置为5，超过之后便清零。

1.4.3参考代码

使用明德扬的计数器模板，可以很快速很熟练地写出时间产生模块。

always@(posedge clk or negedge rst_n)begin
 if(rst_n==1'b0)begin
     flag_set<=1'b0;
 end
 else if(key_vld[0]==1'b1)begin
     flag_set<=~flag_set;
 end
 else begin
     flag_set<=flag_set;
end
end

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    sel_cnt <= 0; 
end
else if(add_sel_cnt) begin
    if(end_sel_cnt)
        sel_cnt <= 0; 
    else
        sel_cnt <= sel_cnt+1 ;
end
end

assign add_sel_cnt = key_vld[1]==1’b1;
assign end_sel_cnt = add_sel_cnt && sel_cnt == 8-1 ;

always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
    set_en<=1'b0;
end
else if(flag_set==1'b1 &&
key_vld[2]==1’b1)begin
    set_en<=1'b1;
end
else begin
    set_en<=1'b0;
end
end

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    counter <= 0; 
end
else if(add_counter) begin
    if(end_counter)
        counter <= 0; 
    else
        counter <= counter+1 ;
end
end

assign add_counter = flag_set==1’b0;
assign end_counter = add_counter && counter == 26’d5000_0000-1;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    sec_low <= 0; 
end
else if(add_sec_low) begin
    if(end_sec_low)
        sec_low <= 0; 
    else
        sec_low <= sec_low+1 ;
end
end

assign add_sec_low = sel_cnt==1-1 &&set_en;
assign end_sec_low = add_sec_low && sec_low == 10-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    sec_high <= 0; 
end
else if(add_sec_high) begin
    if(end_sec_high)
        sec_high <= 0; 
    else
        sec_high <= sec_high+1 ;
end
end

assign add_sec_high = sel_cnt==2-1 &&set_en;
assign end_sec_high = add_sec_high && sec_high == 6-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    min_low <= 0; 
end
else if(add_min_low) begin
    if(end_min_low)
        min_low <= 0; 
    else
        min_low <= min_low+1 ;
end
end

assign add_min_low = sel_cnt==3-1 &&set_en;
assign end_min_low = add_min_low && min_low == 10-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    min_high <= 0; 
end
else if(add_min_high) begin
    if(end_min_high)
        min_high <= 0; 
    else
        min_high <= min_high+1 ;
end
end

assign add_min_high = sel_cnt==4-1 &&set_en;
assign end_min_high = add_min_high && min_high == 6-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    xs_sec_low <= 0; 
end
else if(add_xs_sec_low) begin
    if(end_xs_sec_low)
        xs_sec_low <= 0; 
    else
        xs_sec_low <= xs_sec_low+1 ;
end
end

assign add_xs_sec_low = (sel_cnt==5-1&& set_en) || end_counter;
assign end_xs_sec_low = add_xs_sec_low&& xs_sec_low == 10-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    xs_sec_high <= 0; 
end
else if(add_xs_sec_high) begin
    if(end_xs_sec_high)
        xs_sec_high <= 0; 
    else
        xs_sec_high <= xs_sec_high+1 ;
end
end

assign add_xs_sec_high = (sel_cnt==6-1&& set_en) || end_xs_sec_low;
assign end_xs_sec_high = add_xs_sec_high && xs_sec_high == 6-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    xs_min_low <= 0; 
end
else if(add_xs_min_low) begin
    if(end_xs_min_low)
        xs_min_low <= 0; 
    else
        xs_min_low <= xs_min_low+1 ;
end
end

assign add_xs_min_low = (sel_cnt==7-1&& set_en) || end_xs_sec_high;
assign end_xs_min_low = add_xs_min_low && xs_min_low == 10-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    xs_min_high <= 0; 
end
else if(add_xs_min_high) begin
    if(end_xs_min_high)
        xs_min_high <= 0; 
    else
        xs_min_high <= xs_min_high+1 ;
end
end

assign add_xs_min_high = (sel_cnt==8-1&& set_en) || end_xs_min_low;
assign end_xs_min_high = add_xs_min_high && xs_min_high == 6-1 ;

1.5 数码管显示模块设计

1.5.1接口信号

信号接口方向定义
clk输入系统时钟
rst_n输入低电平复位信号
Segment_data输入时间数据
Segment输出数码管段选信号
Seg_sel输出数码管位选信号

1.5.2设计思路

在前面的案例中已经有数码管显示的介绍，所以这里不在过多介绍，详细介绍请看下方链接：

1.5.3参考代码

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    delay <= 0; 
end
else if(add_delay) begin
    if(end_delay)
        delay <= 0; 
    else
        delay <= delay+1 ;
end
end

assign add_delay = 1;
assign end_delay = add_delay && delay == 2000-1 ;

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    delay_time <= 0; 
end
else if(add_delay_time) begin
    if(end_delay_time)
        delay_time <= 0; 
    else
        delay_time <= delay_time+1 ;
end
end

assign add_delay_time = end_delay;
assign end_delay_time = add_delay_time && delay_time == 8-1 ;
assign segment_tmp = segment_data[(1+delay_time)*4-1 -:4];

always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
    segment <= ZERO;
end
else begin
    case(segment_tmp)
        4'd0:segment <= ZERO;
        4'd1:segment <= ONE  ;
        4'd2:segment <= TWO  ;
        4'd3:segment <= THREE;
        4'd4:segment <= FOUR ;
        4'd5:segment <= FIVE ;
        4'd6:segment <= SIX  ;
        4'd7:segment <= SEVEN;
        4'd8:segment <= EIGHT;
        4'd9:segment <= NINE ;
        default:begin
            segment <= segment;
        end
    endcase
end
end

always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
    seg_sel <= 8'b1111_1111;
end
else begin
    seg_sel <=~(8’b1<<delay_time);
end
end

1.6 蜂鸣器模块设计

1.6.1接口信号

信号接口方向定义
clk输入系统时钟
rst_n输入低电平复位信号
Key1_func输入设置状态指示信号
end_counter输入时钟计数器结束条件，表示1秒的时间
Xs_sec_low输入显示的秒低位计数器
Xs_sec_high输入显示的秒高位计数器
Xs_min_low输入显示的分低位计数器
Xs_min_high输入显示的分高位计数器
Sec_low输入闹钟的秒低位计数器
Sec_high输入闹钟的秒高位计数器
Min_low输入闹钟的分低位计数器
Min_hign输入闹钟的分高位计数器
beep输出蜂鸣器信号

1.6.2设计思路

本模块主要通过将显示时间与设置的闹钟时间进行比较，如果相同的话，就控制beep拉低，持续时间为5秒。由此提出一个计数器的架构，如下图所示。
在这里插入图片描述

该架构由蜂鸣器控制信号beep、秒计数器miao和闹钟触发指示信号flag_add组成。

秒计数器秒：用于对5秒的时间进行计数，加一条件为flag_add && end_counter，表示当闹钟被触发，并且经过1秒的时间就加一；结束条件为5，表示数完5秒就清零。

闹钟触发指示信号flag：当其为高电平时表示闹钟被触发，低电平表示没有被触发。初始状态为低电平，从低变高的条件为
sec_low == xs_sec_low&&sec_high == xs_sec_high&&min_low == xs_min_low&&min_high == xs_min_high&&init&&!key1_func，表示当显示时间的秒高低位、分高低位和闹钟设置的秒高低位、分高低位相等，同时不处于刚上电的初始状态和设置状态时，闹钟被触发；从高变低的条件为end_miao，表示当5秒数完之后，就拉低。

蜂鸣器控制信号beep：当其为低电平时，控制蜂鸣器响，为高电平时不响。初始状态为高电平，从高变低的条件为flag_add，表示计数器开始计数之后便将其拉低，当检测到flag_add=0的时候，便将其拉高。

1.6.3参考代码

always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
    flag_add <= 0;
end
else
if(sec_lowxs_sec_low&&sec_highxs_sec_high&&min_lowxs_min_low&&min_highxs_min_high&&init&&flag_set==0)begin
    flag_add <= 1;
end
else if(end_miao)begin
    flag_add <= 0;
end
end

always@(*)begin
if(!sec_low&&!sec_high&&!min_low&&!min_high)begin
    init=0;
end
else begin
    init=1;
end
end

always @(posedge clk or negedge rst_n) begin
if(rst_n==0) begin
    miao <= 0; 
end
else if(add_miao) begin
    if(end_miao)
        miao <= 0; 
    else
        miao <= miao+1 ;
end
end

assign add_miao = flag_add &&end_counter;
assign end_miao = add_miao && miao == 5-1 ;

always@(posedge clk or negedge rst_n)begin
 if(rst_n==1'b0)begin
    beep<=1'b1;
end
else if(flag_add)begin
    beep<=1'b0;
end
else
    beep<=1'b1;
end

1.7 效果和总结

Ø 下图是该工程在mp801开发板上的现象

其中按键s4控制数字时钟的暂停与开始，按键s3来选择需要设置的位，按键s2设置数值。左边四个数码管显示的是时钟的时间，右边四个数码管显示的是闹钟设置的时间。
在这里插入图片描述

Ø 下图是该工程在db603开发板上的现象

其中按键s1控制数字时钟的暂停与开始，按键s2来选择需要设置的位，按键s3设置数值。左边四个数码管显示的是时钟的时间，右边四个数码管显示的是闹钟设置的时间。
在这里插入图片描述

Ø 下图是该工程在ms980试验箱上的现象

其中按键s1控制数字时钟的暂停与开始，按键s2来选择需要设置的位，按键s3设置数值。左边四个数码管显示的是时钟的时间，右边四个数码管显示的是闹钟设置的时间。
在这里插入图片描述

由于该项目的上板现象是动态的，开始、暂停、时间设置等现象无法通过图片表现出来，想观看完整现象的朋友可以看一下现象演示的视频。

感兴趣的朋友也可以访问论坛进行FPGA相关工程设计习。

MDYFPGA
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
闹钟的设计原理与实现
人既无名的专栏
05-18 1万+
闹钟的设计原理与实现(一)   华中科技大学 陈学友 2012年5月18日     内容摘要 现在很多人由于需要处理各种事物，但是由于某些原因可能会忘记在某个时间段需要完成的工作和其他事情，因此需要一个闹钟来提醒自己，避免忘记这些应该做的事情。如果只有一个提醒事件，情况非常简单，但是对于多事件提醒的闹钟来说，如何解决提醒不冲突，如何使资源占据最小是一个迫切需要解决的问题。本文介绍一个
电子闹钟设计
余小森
01-21 6816
**摘要：**本设计是以89c51单片机作为控制核心的闹铃系统。本文大致可以分三个章节，第一章讲用单片机制作电子闹钟带来的优势，还有电子闹钟在未来的电子产品中的趋势以及本次设计所要实现的课题目标。第二章讲一些设计思路和硬件组成。第三讲程序代码，最后结论，体会，附录图。 **关键词：**pc机，单片机，串行通讯，LCD1602显示。 电了闹钟是一种应用非常广泛的日常计时工具，数字显示的日历钟已经越来...
闹钟设计
weixin_30278237的博客
04-25 219
问题：如果只有一个定时器，如何设置多个闹钟，并不使用全局变量、环境变量等传参 解决：拓展定时器信号的处理函数接口，封装一个结构体，存放定时时间sec,定时模式：mod，计时变量count，超时行为func(),行为函数的参数arg, 为了方便后面删除一个闹钟节点，所以需要一个唯一标示，故用每个节点的地址作为Id, 为了方便查找和删除所以设计成一个双向循环链表。 流程：main函...
简易计时闹钟设计verilog语言实现
qq_44312507的博客
12-17 4340
简易计时闹钟设计verilog语言实现 任务描述: 用电路或verilog语言实现以下功能 简易计时闹钟: 有四位数码管，前两位计分钟，表示00~99分钟， 后面两位记秒，值为00~59秒。 有三个按键，第一个是分键，第 二个是秒键，第三个是启动/暂停键。 功能: 分秒两键同时按下清 零且停止计时，外于设置态，按一次分键分钟加1， 99增1变为0; 按一次秒键秒增1，59增1变为0。 此状态下按启...
Verilog时钟（带闹铃等功能）
06-19
Quartus II：基于FPGA中Verilog语言的时钟，具有闹铃、报时等功能，添加了按键去抖
xiaonaozhong.rar_C设计闹钟_clock_电子 闹钟_电子闹钟_闹钟
09-21
在“小闹钟”文件中，很可能是源代码或者详细的设计文档，我们可以从中学习到如何使用中断、定时器等技术来实现闹钟的计时和闹铃功能。 在实际编程中，我们通常会定义一个时间结构体来存储小时、分钟和秒，然后通过...
dianzizhong.rar_dianzizhong_定时闹钟_电子钟 设计_闹钟
09-23
标题中的“dianzizhong.rar_dianzizhong_定时闹钟_电子钟设计_闹钟”暗示我们正在讨论一个关于电子钟设计的项目，其中包含了定时闹钟的功能。这个项目可能是一个软件或者硬件实现，允许用户设置初始时间和设定定时...
电子设计资料_单片机定时闹钟资料.zip
最新发布
03-15
在这个设计中，我们可以期待看到单片机（可能是8位或16位微控制器）、电源模块、时钟源（如晶振）、显示模块（可能是LED或LCD）、按键输入和可能的音频输出（用于闹铃）等元件的图形表示。通过分析电路图，我们可以...
DIANZIZHONG.rar_时间 闹钟_闹钟
09-23
在程序内部，闹钟设置可能被存储为一系列的数据结构，如数组、链表或者更复杂的数据结构如红黑树。用户查询时，程序会遍历这些数据结构，检索并显示相关信息。如果涉及数据库，可能是使用SQL查询来获取和显示闹钟...
EDA.rar_EDA 电子 仿真_vhdl_vhdl 实例_课程设计_闹钟
09-21
它涵盖了从电路设计、系统级设计、硬件描述语言（HDL）、逻辑综合、布局布线到仿真验证等一系列流程。EDA工具使得工程师能够以更高的效率和精度进行复杂的电子系统设计。 **VHDL简介** VHDL（VHSIC Hardware ...
数据库图片闹钟管理系统
04-12
关于吃药提醒的一个小程序，里面包含listview的运用，包括图片及闹钟存数据库提醒
verilog闹钟程序
02-25
verilog写的闹钟程序，带有 校时 和 闹铃功能。
基于verilog语言的数字时钟设计
07-18
有计时，跑表，闹钟，调整时间四大功能，功能完善，消逗也不错，
verilog编写的数字时钟、万年历、闹钟
03-24
数字钟要求显示时间、日期、闹钟设定时间。利用切换按键进行年月日、时间、闹钟定时操作，三种状态均可用增减两个按键进行调整，对于选中的数码管调整位，通过闪烁表示已经选中，例如：首先切换至日期，选中表示“年”的数码管，那么选中的位进行0.5秒的闪烁表示选中，其次可通过增减按键进行数字的增减。另外在按键消抖后，每次按键按下，蜂鸣器响表示已经按下；设定的闹钟到时候，按下任何按键均停止蜂鸣器，若没有按键按下，蜂鸣器长响至1min时长后，自动停止
FPGA上实现实时时钟，定时器以及蜂鸣提醒
12-31
FPGA上实现实时时钟，定时器以及蜂鸣提醒，附有所有代码及注释。
【Verilog】基于FPGA的闹钟系统设计（功能完整、附代码）
热门推荐
阿汪先生
08-21 1万+
基于FPGA的闹钟系统设计 为了读者能从大的框架上理解整个设计的思路，博主将所有的子文件整合到一个.v文件中，便于读者理解和使用。 `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: //...
Verilog语言fpga小脚丫数字时钟（整点报时，调时，显示秒钟等功能）
qq_40195133的博客
05-30 6545
同时，分钟的计时和时钟的计时实现思路与秒钟计时类似，但需要额外进行判断，比如说分钟进位要在秒钟均为0时才产生进位，时钟进位要在分钟秒钟全为0时才进位。首先只有在秒钟分钟均为0时才算作整点，在这个条件下我又用到了两个计数器cnt、cnt1与加减法的计数器功能一致，cnt为当前整点数的两倍（因为一亮一灭需要灯光反转两次），cnt1为匹配计数器，当cnt1不等于cnt1时灯光反转一次，并且cnt1＋1。我在写代码的时候是将调时模块整合在计时模块中的，时钟调时与分钟调时的原理是相同的。最后便是整点报时的实现。
verilog定时打铃上下课程序设计
QQ_778132974的博客
11-15 565
设计内容如下：其中4，5，6为设计内容！
EDA-Verilog简易闹钟
MoOtA
05-26 1089
module Example(Clk,Hex7,Hex6,Hex5,Hex4,Hex3,Hex2,Hex0,Switch0,Switch4,Switch3,Switch2,Switch1,Led,Clr); reg[31:0] CounterClk=0; reg[31:0] CounterClock=0; reg[31:0] ClockCustom=60; reg ClkPer=0; reg[3:0] H2=0,H1=0,M2=0,M1=0,S2=0,S1=0; reg [31:0]TempH=0,Temp
单片机定时闹钟设计与实现
"单片机定时闹钟设计" 这篇文档详细介绍了如何使用单片机设计一个定时闹钟。设计主要基于STC89C52RC单片机，它在电子信息系统中扮演核心角色，负责处理输入、计算和输出控制。硬件部分包括动态数码管显示器、输入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值