精华内容
下载资源
问答
  • 本课程设计的主题是电子时钟,其基础部分是一个数字钟。电路系统由芯片DS1302组成。利用按键可对时间及闹玲进行设置,并可显示闹玲时间。当闹玲时间到蜂鸣器发出声响,按停止键使可使闹玲声停止。
  • 利用51单片机自带定时器,实现时钟,可调时。电路简单。
  • 说明: # 本程序加载了STM32F103内部的RCC...数码管时钟显示 年月日时间可调 可设置闹钟,到点蜂鸣器响 温度监控,设定温度值达到,蜂鸣器报警,继电器工作 注意: 温度值读取需要时间,可能存在温度刷新不及时问题
  • 利用数码管显示时钟

    千次阅读 2016-10-06 22:34:12
    下面是利用数码管显示时钟的代码 #include #define SEGPORT P0 sbit seg_sel = P2^1;  sbit bit_sel = P2^0;  unsigned char segdata[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; ...
    

    下面是利用数码管显示的时钟的代码

    #include <reg52.h>

    #define SEGPORT P0

    sbit seg_sel = P2^1;   
    sbit bit_sel = P2^0;   

    unsigned char segdata[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
    unsigned char bitdata[8] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
    unsigned char disdata[8] = {0x3f,0x3f,0x40,0x3f,0x3f,0x40,0x03,0x03};   

    unsigned char s = 20;
    unsigned char m = 21;
    unsigned char h = 12;

    void display()
    {
       static unsigned char i = 0;
     
       SEGPORT = 0x0;   
      seg_sel = 1;
      seg_sel = 0;
         
      SEGPORT = 0xff;
      bit_sel = 1;
      bit_sel = 0;
           
      SEGPORT = disdata[i];
      seg_sel = 1;
      seg_sel = 0;
           
      SEGPORT = bitdata[i];
      bit_sel = 1;
      bit_sel = 0;
     
        i++;
     
       if(i == 8)
      {
         i = 0;
      }
    }

    void timer0_init()
    {
       EA = 1;
       TH0 = (65536 - 20000)/256;
       TL0 = (65536 - 20000)%256;
       TMOD |= 0x01;
       ET0 = 1;
       TR0 = 1;
    }

    void timer1_init()
    {
       EA = 1;
       TH1 = (65536 - 1000)/256;
       TL1 = (65536 - 1000)%256;
       TMOD |= 0x10;
       ET1 = 1;
       TR1 = 1;
    }


    void timer0_isr() interrupt 1
    {
       static unsigned char i = 0; 
     
       TH0 = (65536 - 20000)/256;
       TL0 = (65536 - 20000)%256;
     
       i++;
       if(50 == i)
      {
         i = 0;
         s++;
         if(60 == s)
        {
           s = 0;
           m++;
           if(60 == m)
          {
             m = 0;
             h++;
             if(24 == h)
            {
               h = 0;
            }
          }
        }
        }
      
      disdata[0] = segdata[h/10];
      disdata[1] = segdata[h%10];
     
       disdata[3] = segdata[m/10];
      disdata[4] = segdata[m%10];
     
       disdata[6] = segdata[s/10];
      disdata[7] = segdata[s%10];
      
    }

    void timer1_isr() interrupt 3
    {
     
       TH1 = (65536 - 1000)/256;
       TL1 = (65536 - 1000)%256;
     
       display();
    }

    void main()
    {
      
        timer0_init();
       timer1_init();
       while(1);
      
    }

    展开全文
  • 视频效果: 基于51单片机的数码管时钟设计 Proteus 仿真电路图: C51代码: #include typedef unsigned char uchar; typedef unsigned int uint; uchar code num[10]={0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0...

    视频效果:

    基于51单片机的数码管时钟设计

    Proteus 仿真电路图:

    在这里插入图片描述

    C51代码:

    #include<reg51.h>
    
    typedef unsigned char uchar;
    typedef unsigned int uint;
    
    uchar code num[10]={0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90};  // 0~9字码
    
    uchar miao=0, fen=0, shi=0;  //进位标志位
    
    uint i=0;  //计时
    
    uchar miao_L, miao_H, fen_L, fen_H, shi_L, shi_H;  //时、分、秒的个位(xxx_L)和十位(xxx_H)  
    
    void delay(uint x){  //延时函数 
    	while(x--);
    }
    
    void T0_init(){                     //定时器 0 初始化 
    	TMOD = 0x01; //工作方式 1
    	TH0 = 0x3c;  //高八位赋初值    65536-50000=15536 = 3cb0H
    	TL0 = 0xb0;	 //底八位赋初值
    	EA = 1;	     //开总中断
    	ET0 = 1;     //开 T0 中断
    	TR0 = 1;     //启动 T0
    }
    
    void display(){  //显示
    	
    	P2 = 0x20;  //秒与分间隔线
    	P0 = 0xbf;	
    	delay(500);
    		
    	P2 = 0x04;  //分与时间隔线
    	P0 = 0xbf;
    	delay(500);
    
    
    	P2 = 0x80;  //数码管位选 1000 0000
    	P0 = num[miao_L];  //秒个位
    	delay(500);
    
    	P2 = 0x40;	//数码管位选 0100 0000
    	P0 = num[miao_H];  //秒十位
    	delay(500);
    
    	P2 = 0x10;	//数码管位选 0001 0000
    	P0 = num[fen_L];  //分个位
    	delay(500);
    
    	P2 = 0x08;	//数码管位选 0000 1000
    	P0 = num[fen_H];  //分十位
    	delay(500);
    
    	P2 = 0x02;	//数码管位选 0000 0010
    	P0 = num[shi_L];  //分个位
    	delay(500);
    	
    	P2 = 0x01;	//数码管位选 0000 0001
    	P0 = num[shi_H];  //分十位
    	delay(500);
    
    }
    
    void main(){
    
    	T0_init();  //定时器初始化
    
    	while(1){
    
    		display();  //显示		
       }
    
    }
    
    void timer0_int() interrupt 1{  //中断服务函数
     	 
    	 i++;
    
    	 if(i == 20){
    	 	i = 0;  //满一秒清零
    	 	miao++;	//i = 100 为一,秒标志位加 1
    
    		if(miao == 60){
    			miao = 0;  //满一分清零
    			fen++;
    
    			if(fen == 60){
    				fen = 0;  //满一时清零
    				shi++;
    
    				if(shi == 24){
    					shi = 0;  //24小时制
    					fen = 0;
    					miao = 0;
    				}
    			}
    		}
    
    		miao_L = miao%10;  //秒个位
    		miao_H = miao/10;  //秒十位
    
    		fen_L = fen%10;  //分个位
    		fen_H = fen/10;  //分十位
    
    		shi_L = shi%10;  //时个位
    		shi_H = shi/10;  //时十位
    
    	 }
     }
    

    按键实现日期可调的转这篇

    基于51单片机的数码管时钟设计——按键修改时间

    展开全文
  • 资源包含代码和PCB原理图。时钟芯片计时。四位共阴数码管显示时分秒时间,扩展的话也可以显示日月周年,数码管采用74HC138控制位选,74HC573控制段选。独立按键修改时间,LED状态指示灯。
  • c51单片机的课程设计,用八位数码管显示时分秒,动态显示电子时钟
  • 2)计数器模块:产生需要的时钟信号数据 3)数码管驱动:将输入的数据转换为段选、片选信号 1)按键消抖: 这里按键数量用参数代替,增加可重用性 用同步打拍方式检测下降沿 用计数器自检测到下降沿开始计数20ms ...

    目录

    原理

    数码管原理原理
    并且该数码管是共阳极,所以段选低电平有效,片选低电平有效
    段选共用8个引脚

    实现

    思路:
    分三个模块实现:
    1)按键消抖 :按键消抖
    2)计数器模块:产生需要的时钟信号数据
    3)数码管驱动:将输入的数据转换为段选、片选信号

    1)按键消抖:
    这里按键数量用参数代替,增加可重用性
    用同步打拍方式检测下降沿
    用计数器自检测到下降沿开始计数20ms
    输出信号为计数器计数完成后输入取反的值

    module key_debounce #(parameter KEY_W = 3,TIME_20MS = 1000_000)(
    	input					clk		,
    	input					rst_n	,
    	input		[KEY_W-1:0]	key_in 	,
    	
    	output	reg	[KEY_W-1:0]	key_out	 //检测到按下,输出一个周期的高脉冲,其他时刻为0
    );
    	
    //信号定义
    	reg		[19:0]		cnt		;
    	wire				add_cnt	;
    	wire				end_cnt	;
    	reg					add_flag;
    	
    	reg		[KEY_W-1:0]	key_r0	;//同步按键输入
    	reg		[KEY_W-1:0]	key_r1	;//打拍
    	wire	[KEY_W-1:0]	nedge	;//检测下降沿
    	
    //计数器  检测到下降沿的时候,开启计数器延时20ms
    	always @(posedge clk or negedge rst_n)begin 
    		if(!rst_n)begin 
    			cnt <= 0;
    		end
    		else if(add_cnt)begin 
    			if(end_cnt)
    				cnt <= 0;
    			else 
    				cnt <= cnt + 1'b1;
    		end  		
    	end 
    	assign add_cnt = add_flag;
    	assign end_cnt = add_cnt && cnt == TIME_20MS-1;
    	
    	//检测到下降沿的时候,拉高计数器计数使能信号,延时结束时,再拉低使能信号
    	always @(posedge clk or negedge rst_n)begin 
    		if(!rst_n)begin 
    			add_flag <= 1'b0;
    		end 
    		else if(nedge)begin 
    			add_flag <= 1'b1;
    		end 
    		else if(end_cnt)begin 
    			add_flag <= 1'b0;
    		end 
    	end 
    	
    	//同步按键输入,并打一拍,以检测下降沿
    	always @(posedge clk or negedge rst_n)begin 
    		if(!rst_n)begin 
    			key_r0 <= {KEY_W{1'b1}};
    			key_r1 <= {KEY_W{1'b1}};
    		end 
    		else begin 
    			key_r0 <= key_in;//同步
    			key_r1 <= key_r0;//打拍
    		end 
    	end
    	assign nedge = ~key_r0 & key_r1;
    		
    	//延时20ms结束的时钟周期,输出按键的状态,若按下输出一个周期的高脉冲,否则输出0
    	always@(posedge clk or negedge rst_n)begin 
    		if(~rst_n)begin 
    			key_out <= 0;
    		end 
    		else begin 
    			key_out <= end_cnt?~key_r1:0;
    		end 
    	end 
    endmodule 
    

    2)计数器模块
    定义了6个计数器分别代表每位数码管的显示数据
    key[0] 作为设置键,按键信号有效,则可以进行设置操作
    key[1] 作为选择键,用计数器记录当前选择项,默认为m个位
    key[2] 作为+键,按一下当前项+1
    除了正常产生时间数据的计数器,在+1条件中添加了按键设置,即当key[0]有效,key[2]拉高,当前选择项+1
    最后将产生数据组合在一起形成输出数据,每4位代表一个数码管的数据

    module count(
        input           clk     ,
        input           rst_n   ,
        input   [2:0]   key     ,
        output  [23:0]  dout    
    );
    
    parameter TIME_1S = 50_000_000;
    
    reg flag_set;//设置时间标志信号
    
    reg [2:0] cnt_key;//记录按键选择项
    wire add_cnt_key;
    wire end_cnt_key;
    
    reg [25:0] cnt_1s;//1s计数器
    wire add_cnt_1s;
    wire end_cnt_1s;
    
    reg [3:0] cnt0;//s个位计数器
    wire add_cnt0;
    wire end_cnt0;
    
    reg [3:0] cnt1;//s十位计数器
    wire add_cnt1;
    wire end_cnt1;
    
    reg [3:0] cnt2;//m个位计数器
    wire add_cnt2;
    wire end_cnt2;
    
    reg [3:0] cnt3;//m十位计数器
    wire add_cnt3;
    wire end_cnt3;
    
    reg [3:0] cnt4;//h个位计数器
    wire add_cnt4;
    wire end_cnt4;
    
    reg [3:0] cnt5;//h十位计数器
    wire add_cnt5;
    wire end_cnt5;
    
    //设置时间标志项
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            flag_set <= 1'b0;
        end
        else if(key[0])begin
            flag_set <= ~flag_set;
        end
    end
    
    //记录按键选择项
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt_key <= 3'd0;
        end
        else if(add_cnt_key)begin
            if(end_cnt_key)begin
                cnt_key <= 3'd0;
            end
            else begin
                cnt_key <= cnt_key + 1'b1;
            end
        end
    end
    assign add_cnt_key = key[1];
    assign end_cnt_key = add_cnt_key && (cnt_key == 3'd5);
    
    
    //1s计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt_1s <= 26'b0;
        end
        else if(add_cnt_1s)begin
            if(end_cnt_1s)begin
                cnt_1s <= 26'b0;
            end
            else begin
                cnt_1s <= cnt_1s + 1'b1;
            end
        end
    end
    assign add_cnt_1s = 1'b1;
    assign end_cnt_1s = add_cnt_1s && (cnt_1s == TIME_1S - 1);
    
    //s个位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt0 <= 4'b0;
        end
        else if(add_cnt0)begin
            if(end_cnt0)begin
                cnt0 <= 4'b0;
            end
            else begin
                cnt0 <= cnt0 + 1'b1;
            end
        end
    end
    assign add_cnt0 = end_cnt_1s || (flag_set && cnt_key[2:0] == 3'd5 && key[2]);
    assign end_cnt0 = add_cnt0 && (cnt0 == 10 - 1);
    
    //s十位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt1 <= 4'b0;
        end
        else if(add_cnt1)begin
            if(end_cnt1)begin
                cnt1 <= 4'b0;
            end
            else begin
                cnt1 <= cnt1 + 1'b1;
            end
        end
    end
    assign add_cnt1 = end_cnt0 || (flag_set && cnt_key[2:0] == 3'd4 && key[2]);
    assign end_cnt1 = add_cnt1 && (cnt1 == 6 - 1);
    
    //m个位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt2 <= 4'b0;
        end
        else if(add_cnt2)begin
            if(end_cnt2)begin
                cnt2 <= 4'b0;
            end
            else begin
                cnt2 <= cnt2 + 1'b1;
            end
        end
    end
    assign add_cnt2 = end_cnt1 || (flag_set && cnt_key[2:0] == 3'd0 && key[2]);
    assign end_cnt2 = add_cnt2 && (cnt2 == 10 - 1);
    
    //m十位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt3 <= 4'b0;
        end
        else if(add_cnt3)begin
            if(end_cnt3)begin
                cnt3 <= 4'b0;
            end
            else begin
                cnt3 <= cnt3 + 1'b1;
            end
        end
    end
    assign add_cnt3 = end_cnt2 || (flag_set && cnt_key[2:0] == 3'd1 && key[2]);
    assign end_cnt3 = add_cnt3 && (cnt3 == 6 - 1);
    
    //h个位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt4 <= 4'b0;
        end
        else if(add_cnt4)begin
            if(end_cnt4)begin
                cnt4 <= 4'b0;
            end
            else begin
                cnt4 <= cnt4 + 1'b1;
            end
        end
    end
    assign add_cnt4 = end_cnt3 || (flag_set && cnt_key[2:0] == 3'd2 && key[2]);
    assign end_cnt4 = add_cnt4 && (cnt4 == (cnt5 == 2)?(4 - 1):(10 - 1));
    
    //h十位计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt5 <= 4'b0;
        end
        else if(add_cnt5)begin
            if(end_cnt5)begin
                cnt5 <= 4'b0;
            end
            else begin
                cnt5 <= cnt5 + 1'b1;
            end
        end
        else if(flag_set && cnt_key[2:0] == 3'd3 && key[2])begin
            if(cnt5 == 2)begin
                cnt5 <= 4'd0;
            end
            else begin
               cnt5 <= cnt5 +1'b1; 
            end 
        end
    end
    assign add_cnt5 = end_cnt4;
    assign end_cnt5 = add_cnt5 && (cnt5 == 2);
    
    assign dout = {cnt5,cnt4,cnt3,cnt2,cnt1,cnt0};
    
    endmodule
    
    

    3)数码管驱动模块
    这里每0.5ms刷新一次数码管,即每0.5ms重新显示数码管,根据人眼的暂留效应,可以达到常亮的效果
    并且每0.5ms换一次片选信号,实现动态显示的效果(其实就是在一个0.5ms内,只显示了一个数码管,但因为时间太短,我们察觉不到,感觉是常亮)
    在切换片选信号的同时,将对应的段选信号赋给[3:0] data
    最后,查找字典,将data中数据转换为数码管需要的格式

    module seg_driver(
        input               clk     ,
        input               rst_n   ,
        input      [23:0]   din     ,
        output reg [5:0]    sel     ,
        output reg [7:0]    dig     
    );
    
    parameter TIME_10MS = 25_000;
    //共阳极数码管  低电平点亮
        localparam  ZERO     = 7'b100_0000,
                    ONE      = 7'b111_1001,
                    TWO      = 7'b010_0100,   
                    THREE    = 7'b011_0000,   
                    FOUR     = 7'b001_1001,
                    FIVE     = 7'b001_0010, 
                    SIX      = 7'b000_0010, 
                    SEVEN    = 7'b111_1000, 
                    EIGHT    = 7'b000_0000,
                    NINE     = 7'b001_0000;
    
    //信号定义
    
    reg dot;
    
    reg [19:0] cnt;//扫描计数器
    wire add_cnt;
    wire end_cnt;
    
    reg [3:0] data;//根据片选信号选择对应数码管数据
    
    //刷新频率计数器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt <= 0;
        end
        else if(add_cnt)begin
            if(end_cnt)begin
                cnt <= 0;
            end
            else begin
               cnt <= cnt + 1'b1;
            end
        end
    end
    assign add_cnt = 1'b1;
    assign end_cnt = add_cnt && (cnt == TIME_10MS - 1);
    //片选信号选择
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            sel <= 6'b111_110;;
        end
        else if(end_cnt)begin
            sel <= {sel[0],sel[5:1]};
    	 end
    end
    
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n)begin
            data <= 4'b0;
        end
        else begin
           case(sel)
                6'b111_110: begin data <= din [3:0]     ;dot <=  1'b1;end
                6'b111_101: begin data <= din [7:4]     ;dot <=  1'b1;end
                6'b111_011: begin data <= din [11:8]    ;dot <=  1'b0;end
                6'b110_111: begin data <= din [15:12]   ;dot <=  1'b1;end
                6'b101_111: begin data <= din [19:16]   ;dot <=  1'b0;end
                6'b011_111: begin data <= din [23:20]   ;dot <=  1'b1;end
                default: data <= din[3:0];
            endcase 
        end
         
    end
    
    always @(*) begin
        case(data)
            4'd0:dig = {dot,ZERO }   ;
            4'd1:dig = {dot,ONE  }   ;
            4'd2:dig = {dot,TWO  }   ;
            4'd3:dig = {dot,THREE}   ;
            4'd4:dig = {dot,FOUR }   ;
            4'd5:dig = {dot,FIVE }   ;
            4'd6:dig = {dot,SIX  }   ;
            4'd7:dig = {dot,SEVEN}   ;
            4'd8:dig = {dot,EIGHT}   ;
            4'd9:dig = {dot,NINE }   ;
            default: dig = ZERO;
        endcase
    end
    endmodule
    

    最后的主模块,就是个外壳

    module shizhong(
        input clk,
        input rst_n,
        input [2:0] key_in,
        output [5:0] sel,
        output [7:0] dig
    );
    wire [2:0] key_out;
    wire [23:0] dout;
    key_debounce #(.KEY_W(3)) u_key_debounce(
    	.clk		(clk		),
    	.rst_n	    (rst_n	    ),
    	.key_in 	(key_in 	),
    	.key_out	(key_out	) //检测到按下,输出一个周期的高脉冲,其他时刻为0
    );
    
    count u_count(
        .clk     (clk    ),
        .rst_n   (rst_n  ),
        .key     (key_out),
        .dout    (dout   )
    );
    
    seg_driver u_seg_driver(
        .clk     (clk     ),
        .rst_n   (rst_n   ),
        .din     (dout    ),
        .sel     (sel     ),
        .dig     (dig     )
    );
    
    endmodule
    

    实测没有太大的bug
    总结:开始的时候感觉就不是人写的,又要产生时钟数据,又要按键控制,甚至开始连动态显示都不知道怎么写,在老师的讲解下,加上自己查阅博客,最终还是吧代码搞定了,至于quartus中其他的警告,其中有很多还是搞不清楚,时序问题的话,把sdc文件中的时钟改成周期20ns的就行,更多的警告就搞不定了。

    展开全文
  • 在八段数码管显示时间的驱动程序


    #include <reg52.h>
    
    #define SEGPORT P0
    sbit seg_select = P2^1;        
    sbit bit_select = P2^0;          
    
    unsigned char duanma[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};               
    unsigned char weima[8] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f}; 
    unsigned char TempData[8];
    
    unsigned char shi = 20, fen = 54, miao = 55;
    
    void display()
    {
    	  static unsigned char i = 0;
    	  SEGPORT = 0x0;
    	  seg_select = 1;
    	  seg_select = 0;
    	  
    	  SEGPORT = 0xff;
    	  bit_select = 1;
    	  bit_select = 0;
    	
    	  SEGPORT = TempData[i];
    	  seg_select = 1;
    	  seg_select = 0;
    	  
    	  SEGPORT = weima[i];
    	  bit_select = 1;
    	  bit_select = 0;
    	  
    		i++;
    	
    	  if(8 == i)
    		{
    				i = 0;
        }  
    }
    
    void time0_init(void)
    {
    	  EA = 1;                              //打开总中断
    	  TMOD |= 0x01;                        //设置定时器工作方式
    	  TH0 = (65536 - 20000) / 256;
    	  TL0 = (65536 - 20000) % 256;        //设置定时器初值
    	  ET0 = 1;                           //打开定时器中断
    	  TR0 = 1;
    
    }
    
    void timer0_isr() interrupt 1
    {
    	  static unsigned char i = 0;
              TH0 = (65536 - 20000) / 256;
    	  TL0 = (65536 - 20000) % 256;    //设置定时器初值,
    	  i++;	
    	  
    		if(50 == i)	
    		{
    				i = 0;
    				miao++;
    				if(60 == miao)
    				{
    			 
    						miao = 0;
    						fen++;
    				  
    						if(60 == fen)
    						{
    								fen = 0;
    								shi++;
    						  
    								if(24 == shi)
    								{
    										shi = 0;
    							  
    								}
    						}
    					}
    		}
    		
    		TempData[0] = duanma[shi / 10];
    		TempData[1] = duanma[shi % 10];
    		TempData[2] = 0x40;
    		TempData[3] = duanma[fen / 10];
    		TempData[4] = duanma[fen % 10];
    		TempData[5] = 0x40;
    		TempData[6] = duanma[miao / 10];
    		TempData[7] = duanma[miao % 10];
    }
    
    void time1_init(void)
    {
              EA = 1;
    	  TMOD |= 0x10;
    	  TH1 = (65536 - 20000) / 256;
    	  TL1 = (65536 - 20000) % 256;
    	  ET1 = 1;
    	  TR1 = 1;
    		
    	 
    }
    
    void time1_isr() interrupt 3
    {
              TH1 = (65536 - 1000) / 256;
    	  TL1 = (65536 - 1000) % 256;     
    	  display();
    		
    }               
    
    void main()
    {
    	 time0_init();
    	 time1_init();
    	 while(1)
    	 {
       
             }
    						   
    }
    


    展开全文
  • 基于51单片机的电子时钟数码管显示

    万次阅读 多人点赞 2018-05-20 08:30:59
    此次对于数码管进行一个简单的应用,同时可以设计一个电子小时钟,增加趣味性。首先我们先进行原理图的讲解,这里我们直接使用的开发板,其原理连接图如下: 从图中,我们...第二个74HC573是来控制数码管显示什么的...
  • 74HC595是具有8位移位寄存器和一个存储器,三态输出...移位寄存器和存储器是分别的时钟。数据在SCK的上升沿输入,在RCK的上升沿进入的存储寄存器中去。如果两个时钟连在一起,则移位寄存器总是比存储寄存器早一个脉冲。
  • Python写的,用七段数码管的方式显示当前日期的程序。
  • 一、实现功能 二、电路原理图 三、代码实现 (这里只列出部分代码,想获取全部代码的话看文末置顶评论) #include<reg52.h> //--定义使用的IO口--// ... 0xfe,0xfd,0xfb,0xf7,0xef,0xdf,
  • 利 用 定 时 器 T 0 计 时 的 电 子 时 钟 , 可 暂 停 计 时,亦 可 修 改 时 分 秒 。8 位 数码 管 , 利 用 5 7 3 锁 存 器 控 制。
  • 利用labview中的一些空间可以创建出数码管,并将当前的时钟显示出来
  • 基于51单片机的8位数码管显示时钟的汇编代码,可切换时间、日期模式
  • 基于FPGA的数字钟——(三)数码管显示模块 硬件原理 本设计中使用 6 个共阳数码管,可以显示 6 个数字(包含小数点) 。电路用 PNP管来反向驱动并且控制列扫描信号来选择哪个数码管。而且所有的 6 个数码管的“段选...
  • 本文主要介绍如何用VHDL设计一个时钟(可以产生时分秒的信号),然后用数码管显示出时分秒。 设计思路: 设计两个模块,一个模块负责产生时分秒的信号,另一个模块负责驱动数码管显示出时分秒的时间。然后在顶层模块...
  • 数码管显示问题总结

    千次阅读 2019-06-19 23:33:31
    1.数码管显示原理 我们最常用的是七段式和八段式LED数码管,八段比七段多了一个小数点,其他的基本相同。所谓的八段就是指数码管里有八个小LED发光二极管,通过控制不同的LED的亮灭来显示出不同的字形。数码管又...
  • 数码管八位显示时钟

    千次阅读 2017-06-01 10:23:00
    /* 八位时钟 */ #include <reg51.h> #include <stdio.h> #define uchar unsigned char #define uint unsigned int uchar code duanca[10]={0x3F,0x06,0x5B,0x4F,0x66...
  • 利用已经建立的工程模板,在Keil for ARM V5中编写代码,实现如下功能:配置相应的GPIO口为通用输出口,配置STM32的定时器3,使数码管循环显示从0~9的数字,每1秒钟数字加1。 main.c: #include "stm32f10x.h" #...
  • 开发板的使用是AX301,学习资料可以在我的另一篇文章中找到。链接在如下:...一、按键消抖的实验 二、时钟实验 声明:该文只适用于学习,其内容包含来自书本的摘抄和总结,欢迎大家补充,共同学习进步。 ...
  • 根据数码管动态显示的原理和模块化设计的思想,该实例的电路框图设想如下: 实例一电路框图 如上图所示,既然涉及数码管显示,显示译码的部分是必不可少的,该模块由两个译码器组成,分别负责数码管位选译码和段码...
  • 利用数码管显示时间(非当前时间) #include<reg52.h> #define uint unsigned int #define uchar unsigned char uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; sbit dula=P2^6; ...
  • 可以通过独立按键修改时钟 也可以通过串口通讯修改接收时间 已经测试并且成功
  • 用7段共阳数码管显示任意一个4位数的verilog程序,如果你的数码管是共阴极,你知道怎么改。另外,把要显示的数N改成输入,就可以加到其他模块里面去被调用了。
  • STC系列单片机PCA的应用,是初学者的敲门砖,用Fosc/12为时钟源,键盘显示芯片显示中断次数,是我亲手调好的程序,与大家分享
  • 数码管时钟秒表.zip

    2021-04-04 13:30:34
    1、用单片机及6位LED数码管显示时分秒;2、时间以24小时计时方式运行,并能整点提醒;3、利用按键功能开关实现时分调整,秒表功能切换,省电及定时中断等功能。包含代码和protues仿真,有问题联系VX:F9986858
  • 基于51单片机的数码管时钟设计——按键修改时间

    千次阅读 多人点赞 2020-12-16 17:51:18
    视频演示 哔哩哔哩视频演示 Proteus 仿真图 代码: #include typedef unsigned char uchar; typedef unsigned int uint; //按键定义 sbit key_stop = P3^0;... } }//timer0_Init 完整工程 时钟——两组实验.zip
  • Python实现七段数码管时钟(动态刷新版)

    千次阅读 多人点赞 2020-06-14 18:19:04
    利用turtle库、datetime库和time库,获取并描绘出现在的系统时间,并且时间具有动态刷新功能,即每秒刷新一次。 实现代码如下: from turtle import * from datetime import datetime import time def drawGap(): ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,013
精华内容 805
关键字:

利用数码管显示时钟