毫秒计时器

最新推荐文章于 2025-05-21 12:22:10 发布
转载 最新推荐文章于 2025-05-21 12:22:10 发布 · 851 阅读 · 0 

    // millitimer.v  
    `timescale 1ns / 1ps  
      
    module millitimer(  
        input start_btn,  
        input stop_btn,  
        input inc_btn,  
        input clk,  
        input rst,  
        output [3:0] an,  
        output [6:0] seg,  
        output dp  
        );  
          
        parameter DP_SELECT = 3'b111;  
          
        wire mclk;  
        wire cen;  
        wire [15:0] data;  
          
        timer_fsm u_tfs (  
            .start(start_btn),  
            .stop(stop_btn),  
            .inc(inc_btn),  
            .clk(mclk),  
            .rst(rst),  
            .cen(cen)  
        );  
          
        clk_divider u_clk_d (  
            .clk(clk),  
            .rst(rst),  
            .mclk(mclk)  
        );  
          
        counter u_count (  
            .cen(cen),  
            .clk(mclk),  
            .rst(rst),  
            .out(data)  
        );  
          
        seg7_controller u_seg7_ctrl (  
            .en(1'b1),  
            .data(data),  
            .dp_select(DP_SELECT),  
            .clk(mclk),  
            .rst(rst),  
            .an(an),  
            .seg(seg),  
            .dp(dp)  
        );  
          
    endmodule  

 


    // clk_divider.v  
    `timescale 1ns / 1ps  
      
    module clk_divider(  
        input clk,  
        input rst,  
        output reg mclk  
        );  
      
        parameter CLK_COUNT = 4; // 板级验证的时候该值改为49999  
        reg [31:0] count;  
          
        always @ (posedge clk or posedge rst)  
        begin  
            if (rst) begin  
                count <= 0;  
                mclk <= 0;  
            end  
            else if (count == CLK_COUNT) begin  
                count <= 0;  
                mclk <= ~mclk;  
            end  
            else begin  
                count <= count+1;  
                mclk <= mclk;  
            end  
        end  
      
    endmodule  

 


    // timer_fsm.v  
    `timescale 1ns / 1ps  
      
    module timer_fsm(  
        input start,  
        input stop,  
        input inc,  
        input clk,  
        input rst,  
        output reg cen  
        );  
          
        parameter STOP = 2'b00;  
        parameter START = 2'b01;  
        parameter INC = 2'b10;  
        parameter TRAP = 2'b11;  
          
        reg [1:0] state, nextstate;  
          
        always @(posedge clk or posedge rst)  
        begin  
            if (rst)  
                state <= STOP;  
            else  
                state <= nextstate;  
        end  
          
        always @(*)  
        begin  
            case (state)  
                STOP:  
                    if (stop) nextstate = STOP;  
                    else if (start) nextstate = START;  
                    else if (inc) nextstate = INC;  
                    else nextstate = STOP;  
                START:  
                    if (start) nextstate = START;  
                    else if (stop) nextstate = STOP;  
                    else nextstate = START;  
                INC:  
                    nextstate = TRAP;  
                TRAP:  
                    if (inc) nextstate = TRAP;  
                    else nextstate = STOP;  
            endcase  
        end  
          
        always @(*)  
        begin  
            case (state)  
                STOP: cen = 1'b0;  
                START: cen = 1'b1;  
                INC: cen = 1'b1;  
                TRAP: cen = 1'b0;  
            endcase  
        end  
          
    endmodule  

 


    // counter.v  
    `timescale 1ns / 1ps  
      
    module counter(  
        input cen,  
        input clk,  
        input rst,  
        output [15:0] out  
        );  
      
        wire tc0, tc1, tc2;  
          
        counter4b u_c41 (  
            .cen(cen),  
            .clk(clk),  
            .rst(rst),  
            .out(out[3:0]),  
            .tc(tc0)  
        );  
        counter4b u_c42 (  
            .cen(cen & tc0),  
            .clk(clk),  
            .rst(rst),  
            .out(out[7:4]),  
            .tc(tc1)  
        );  
        counter4b u_c43 (  
            .cen(cen & tc0 & tc1),  
            .clk(clk),  
            .rst(rst),  
            .out(out[11:8]),  
            .tc(tc2)  
        );  
        counter4b u_c44 (  
            .cen(cen & tc0 & tc1 & tc2),  
            .clk(clk),  
            .rst(rst),  
            .out(out[15:12]),  
            .tc()  
        );  
      
    endmodule  
      
      
    module counter4b (  
        input cen,  
         input clk,  
         input rst,  
         output reg [3:0] out,  
         output tc  
        );  
      
        assign tc = (out == 4'b1001) ? 1'b1 : 1'b0;  
      
        always @ (posedge clk or posedge rst)  
        begin  
            if (rst) begin  
                out <= 0;  
            end  
            else if (cen) begin  
                if (out == 4'b1001)  
                    out <= 0;  
                else  
                    out <= out+1;  
            end  
            else begin  
                out <= out;  
            end  
        end  
      
    endmodule  

 


    // seg7_controller.v  
    `timescale 1ns / 1ps  
      
    module seg7_controller(  
        input en,  
        input [15:0] data,  
        input [2:0] dp_select,  
        input clk,  
        input rst,  
        output reg [3:0] an,  
        output reg[6:0] seg,  
        output dp  
        );  
      
        reg [1:0] count;  
        reg [3:0] selected_data;  
          
        assign dp = (dp_select[2] && (dp_select[1:0]==count)) ? 1'b0 : 1'b1;  
          
        always @ (posedge clk or posedge rst)  
        begin  
            if (rst)  
                count <= 0;  
            else if (!en)  
                count <= 0;  
            else if (count == 2'b11)  
                count <= 0;  
            else  
                count <= count+1;  
        end  
          
        always @ (*)  
        begin  
            if (en) begin  
                case (count)  
                    2'b00: an = 4'b1110;  
                    2'b01: an = 4'b1101;  
                    2'b10: an = 4'b1011;  
                    2'b11: an = 4'b0111;  
                    default: an = 4'b1111;  
                endcase  
            end  
            else begin  
                an = 4'b1111;  
            end  
        end  
          
        always @ (*)  
        begin  
            case (count)  
                2'b00: selected_data = data[3:0];  
                2'b01: selected_data = data[7:4];  
                2'b10: selected_data = data[11:8];  
                2'b11: selected_data = data[15:12];  
                default: selected_data = 4'b0000;  
            endcase  
        end  
          
        always @ (*)  
        begin  
            case (selected_data)  
                4'b0000: seg = 7'b0000001;  
                4'b0001: seg = 7'b1001111;  
                4'b0010: seg = 7'b0010010;  
                4'b0011: seg = 7'b0000110;  
                4'b0100: seg = 7'b1001100;  
                4'b0101: seg = 7'b0100100;  
                4'b0110: seg = 7'b0100000;  
                4'b0111: seg = 7'b0001111;  
                4'b1000: seg = 7'b0000000;  
                4'b1001: seg = 7'b0000100;  
                default: seg = 7'b1111111;  
            endcase  
        end  
      
    endmodule  

 
//Millitimer_test.v代码  收藏代码

    // 仿真测试文件：millitimer_test.v  
    `timescale 1ns / 1ps  
      
    module millitimer_test;  
      
        // Inputs  
        reg start_btn;  
        reg stop_btn;  
        reg inc_btn;  
        reg clk;  
        reg rst;  
      
        // Outputs  
        wire [3:0] an;  
        wire [6:0] seg;  
        wire dp;  
      
        // Instantiate the Unit Under Test (UUT)  
        millitimer uut (  
            .start_btn(start_btn),   
            .stop_btn(stop_btn),   
            .inc_btn(inc_btn),   
            .clk(clk),   
            .rst(rst),   
            .an(an),   
            .seg(seg),   
            .dp(dp)  
        );  
      
        initial begin  
            // Initialize Inputs  
            start_btn = 0;  
            stop_btn = 0;  
            inc_btn = 0;  
            clk = 0;  
            rst = 0;  
      
            // Wait 100 ns for global reset to finish  
            #100;  
              
            // Add stimulus here  
            rst = 1;  
            #100;  
            rst = 0;  
            #100;  
            start_btn = 1;  
            #1200;  
            start_btn = 0;  
            stop_btn = 1;  
            #200;  
            inc_btn = 1;  
            #200;  
            stop_btn = 0;  
            #200;  
            start_btn = 1;  
            #200;  
            inc_btn = 0;  
            #200;  
            rst = 1;  
            #200;  
            rst = 0;  
        end  
          
        always #5  
            clk = ~clk;  
            
    endmodule

反应计时器设计+毫秒计时器+延时计数器模块（Verilog）
05-10
手眼协调是一种眼睛和手一起工作执行一项任务的能力，反应计时器电路能够测量一个 人在看见一种视觉刺激后，手的响应有多快。 实验要求： 1. 基本部分 （1）电路有三个输入按键：clear，start 和 stop，使用一个 ...
电脑毫秒级计时器
10-22
电脑计时器，毫秒级，相当精确。值得下载
js中毫秒计时器
MISS_zhang_0110的博客
11-12 2375
vue项目中毫秒计时器一、效果图二、代码 一、效果图 二、代码 //html <ul class="time"> <li>{{hour}}</li>: <li>{{minute}}</li>: <li>{{second}}</li>: <li>{{String(millisecond).slice(0, 2) }}</li> </ul&gt
android带毫秒的计时器
05-18
Android组件Chronometer不支持毫秒显示，自己写的小案例，希望能给大家 一个思路，有待完善。
简单计时器（毫秒）源代码
06-28
是一个 简单的毫秒计时工具。可以记录五条记录。课进行清空
Timer计时器可以精确到毫秒
12-03
使用QueryPerformanceFrequency（）和QueryPerformanceCounter（）来计算精确时间，支持计时暂停。
秒表 （精确到毫秒，字体大）
08-25
秒表 （精确到毫秒，字体大，简洁明了，可以用于各种测时）
反应时间测试
09-15
这个小程序可以测试你的反应时间，界面美观，计时准确，可自选要进行测试所使用的颜色。
手眼反应计数器
08-24
测试手眼反应速度，当按下开始键时，led灯熄灭1~6s，时间不定，然后点亮，眼睛看到led灯亮后按下停止键，此时数码管显示时间即为手眼反应时间。可实现两人比赛，获胜者对应的led灯会点亮；还可查询所有反应时间的最值。
计时器设计图
01-02
嘛就是一个计时器的设计mlltisim的文件
Swift实现的用户体验设计毫秒计时器
最新发布
weixin_31315007的博客
05-21 735
在本章中，我们深入了解了计时精度校准与补偿的重要性、技术实现方法和实际代码示例。通过识别和分类误差源，并采取适当的校准和补偿措施，开发者可以显著提高计时器的准确性。无论是选择实时校准还是周期性校准，关键在于不断地监测计时器的性能，并根据需要进行调整。在实现校准策略时，还需综合考虑操作系统的行为、硬件性能和环境因素，以确保计时器在各种条件下均能准确运行。
iOS毫秒倒计时的实现
若锦的博客
01-11 3457
app开发中，当展示限时优惠的某些商品时，往往会加一个倒计时，提示用户该商品限时优惠所剩的时间，。那对于开发者来说，这就需要我们去实现的是一个倒计时的功能，这个倒计时根据具体需求，可以以天、小时、分、秒、毫秒作单位。今天呢，主要说说毫秒计时器。我们知道秒和毫秒之间的进制是1000，也就是说1秒=1000毫秒，那我们做毫秒倒计时器的时候是设置一个时间间隔为1毫秒的计时器，逐一减少毫秒数。但是这样的话太
Verilog实现毫秒级计时器(秒表)
热门推荐
MarshalRUAN
12-04 1万+
Verilog实现毫秒级计时器(秒表)    功能描述     使用Verilog语言在Nexys3开发板上实现一个毫秒精度的计时器。       计时器从0.000s开始计时到9.999s，然后重头开始计时，如此往复。Nexys3开发板上7段译码管要实时显示当前计数时间值和小数点。另外，跟一般的秒表类似，本文实现的计时器有4个控制按钮，分别为reset，start，stop以及in...
element计数器触发延迟数据
qq_40748809的博客
04-18 921
<el-input-number @change=“getPrice” v-model=“a” :min=“1” :max=“99” :step=“1” style=“margin-bottom:10px;”> getPrice() { console.log(this.a) } 在触发方法种如果不传入value会导致打印的a不是最新的值，所以要加上 getPrice(value) {...
精确毫秒计时器的实现与应用
标题：“Timer计时器可以精确到毫秒” 知识点说明： 1. 计时器的精确度：计时器（Timer）在编程中是一个非常重要的组件，尤其当需要精确控制时间间隔，执行周期性任务或者测量时间间隔的时候。标题指出的“精确到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值