基于52单片机的电子时钟(原理图,代码)

这篇具有很好参考价值的文章主要介绍了基于52单片机的电子时钟(原理图,代码)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

所需要使用的元器件:51单片机计时器代码,单片机,51单片机

 代码:(使用的是keil5)

#include <reg52.h>             //调用单片机头文件
#define uchar unsigned char  //无符号字符型 宏定义    变量范围0~255
#define uint  unsigned int     //无符号整型 宏定义    变量范围0~65535
 
//数码管段选定义      0     1    2    3    4    5      6     7      8       9    
uchar code smg_du[]={0xa0,0xbb,0x62,0x2a,0x39,0x2c,0x24,0xBa,0x20,0x28,
                       0x30,0x25,0xe4,0x23,0x64,0x74,0xff};     //断码
 
//数码管位选定义
uchar code smg_we[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//数码管位选定义
uchar dis_smg[8] = {0};    

bit flag_200ms ;
bit flag_100ms ;
 
sbit beep = P3^7;      //蜂鸣器定义
bit flag_beep_en;
uint clock_value;     //用作闹钟用的
uchar flag_s = 0x03;//控制数码管闪烁的变量

sbit clk = P1^3;      //ds1302时钟线定义
sbit io =  P1^4;      //数据线
sbit rst = P1^5;      //复位线
                        //秒  分   时   日   月  年   星期     
uchar code write_add[]={0x80,0x82,0x84,0x86,0x88,0x8c,0x8a};   //写地址
uchar code read_add[] ={0x81,0x83,0x85,0x87,0x89,0x8d,0x8b};   //读地址
uchar miao,fen,shi,ri,yue,week,nian;
uchar i;
uchar fen1=3,shi1=8;      //闹钟变量的定义
uchar open1;

uchar menu_1,menu_2;

sbit key1 = P3^6;        //按键IO口定义
sbit key2 = P3^5;        //按键IO口定义
sbit key3 = P3^4;        //按键IO口定义
sbit key4 = P3^3;        //按键IO口定义
  
/*************写一个数据到对应的地址里***************/
void write_ds1302(uchar add,uchar dat)
{        
    rst = 1;             //把复位线拿高
    for(i=0;i<8;i++)
    {                     //低位在前
        clk = 0;         //时钟线拿低开始写数据
        io = add & 0x01;        
        add >>= 1;         //把地址右移一位
        clk = 1;         //时钟线拿高
    }    
    for(i=0;i<8;i++)
    {
        clk = 0;         //时钟线拿低开始写数据
        io = dat & 0x01;
        dat >>= 1;         //把数据右移一位
        clk = 1;         //时钟线拿高
    }
    rst = 0;             //复位线合低
}

/*************从对应的地址读一个数据出来***************/
uchar read_ds1302(uchar add)
{
    uchar value,i;
    rst = 1;             //把复位线拿高
    for(i=0;i<8;i++)
    {                     //低位在前
        clk = 0;         //时钟线拿低开始写数据
        io = add & 0x01;        
        add >>= 1;         //把地址右移一位
        clk = 1;         //时钟线拿高
    }        
    for(i=0;i<8;i++)
    {
        clk = 0;         //时钟线拿低开始读数据
        value >>= 1;
        if(io == 1)
            value |= 0x80;
        clk = 1;         //时钟线拿高
    }
    rst = 0;             //复位线合低
    return value;         //返回读出来的数据
}

/*************把要的时间 年月日 都读出来***************/
void read_time()
{
    miao = read_ds1302(read_add[0]);    //读秒
    fen  = read_ds1302(read_add[1]);    //读分
    shi  = read_ds1302(read_add[2]);    //读时
    ri   = read_ds1302(read_add[3]);    //读日
    yue  = read_ds1302(read_add[4]);    //读月
    nian = read_ds1302(read_add[5]);    //读年
    week = read_ds1302(read_add[6]);    //读星期
}

/*************把要写的时间 年月日 都写入ds1302里***************/
void write_time()      //把时间写进去
{
    write_ds1302(0x8e,0x00);            //打开写保护
    write_ds1302(write_add[0],miao);    //写秒
    write_ds1302(write_add[1],fen);        //写分
    write_ds1302(write_add[2],shi);        //写时
    write_ds1302(write_add[3],ri);        //写日
    write_ds1302(write_add[4],yue);        //写月
    write_ds1302(write_add[5],nian);    //写星期
    write_ds1302(write_add[6],week);    //写年
    write_ds1302(0x8e,0x80);            //关闭写保护
}
 
/***********************1ms延时函数*****************************/
void delay_1ms(uint q)
{
    uint i,j;
    for(i=0;i<q;i++)
        for(j=0;j<120;j++);
}

/********************独立按键程序*****************/
uchar key_can;     //按键值

void key()     //独立按键程序
{
    uchar key_new;        //key_new  这个变量的功能是做按键松手检测的 
    key_can = 0;                //按键值还原成0
     if(key1 == 0 || key2 == 0 || key3 == 0 || key4 == 0)        //有按键按下 
    {
        delay_1ms(1);             //按键延时消抖动
        if(key_new == 1)
        {                     
            key_new = 0;        //key_new = 0   说明按键已按下
            if(key1 == 0)        //确认是按键按下
                key_can = 1;     //得到按键值 
            if(key2 == 0)        //确认是按键按下
                key_can = 2;     //得到按键值 
            if(key3 == 0)        //确认是按键按下
                key_can = 3;     //得到按键值 
            if(key4 == 0)        //确认是按键按下
                key_can = 4;     //得到按键值 
        }            
    }
    else 
        key_new = 1;     //key_new = 1   说明按键已经松开了    
}


/**********************设置函数************************/
void key_with()
{
     if(key_can == 1)    //设置键
    {
        menu_1++;
        menu_2 = 1;
        if(menu_1 == 1)      //设置时间
            flag_s = 0x03;
        if(menu_1 == 2)      //设置年 月  日
            flag_s = 0x03;
        if(menu_1 == 3)      //设置星期 闹钟的开和关
            flag_s = 0x03;
        if(menu_1 == 4)       设置 闹钟
            flag_s = 0x0c;
        if(menu_1 > 4)    //回到正常显示
        {
            menu_1 = 0;

        }
    }
    if(key_can == 2)    //选择键
    {
        flag_200ms = 1;
        if((menu_1 == 1) || (menu_1 == 2))          //设置时间
        {
            menu_2 ++;
            if(menu_2 > 3)
                menu_2 = 1;
            if(menu_2 == 1)
                flag_s = 0x03;
            if(menu_2 == 2)
                flag_s = 0x18;
            if(menu_2 == 3)
                flag_s = 0xc0;
        }
        if(menu_1 == 3)          //设置星期 闹钟的开和关
        {
            menu_2 ++;
            if(menu_2 > 2)
                menu_2 = 1;
            if(menu_2 == 1)
                flag_s = 0x03;
            if(menu_2 == 2)
                flag_s = 0xf8;
        }
        if(menu_1 == 4)          //设置 闹钟
        {
            menu_2 ++;
            if(menu_2 > 2)
                menu_2 = 1;
            if(menu_2 == 1)
                flag_s = 0x0c;
            if(menu_2 == 2)
                flag_s = 0x60;
        }
    }
    if(menu_1 == 1)           //
    {
        if(menu_2 == 1)          //设置秒
        {
            if(key_can == 3)    //加键 
            {
                miao+=0x01;        //设置秒钟加1 
                if((miao & 0x0f) >= 0x0a)
                    miao = (miao & 0xf0) + 0x10;
                if(miao >= 0x60)
                    miao = 0;
            }    
            if(key_can == 4)    //减键       
            {
                if(miao == 0x00)
                    miao = 0x5a;
                if((miao & 0x0f) == 0x00)
                    miao = (miao | 0x0a) - 0x10;
                miao -- ;        //设置秒减1        
            }
         }
        if(menu_2 == 2)          //设置分
        {
            if(key_can == 3)    //加键 
            {
                fen+=0x01;        //设置分钟加1 
                if((fen & 0x0f) >= 0x0a)
                    fen = (fen & 0xf0) + 0x10;
                if(fen >= 0x60)
                    fen = 0;
            }        
            if(key_can == 4)    //减键       
            {
                if(fen == 0x00)
                    fen = 0x5a;
                if((fen & 0x0f) == 0x00)
                    fen = (fen | 0x0a) - 0x10;
                fen -- ;       //设置分钟减1 
            }    
        }
        if(menu_2 == 3)          //设置时
        {
            if(key_can == 3)    //加键 
            {
                shi+=0x01;        //设置时钟加1 
                if((shi & 0x0f) >= 0x0a)
                    shi = (shi & 0xf0) + 0x10;
                if(shi >= 0x24)
                    shi = 0;
            }        
            if(key_can == 4)    //减键 
            {
                if(shi == 0x00)
                    shi = 0x24;
                if((shi & 0x0f) == 0x00)
                    shi = (shi | 0x0a) - 0x10;
                shi -- ;        //设置时钟减1 
            }        
        }
        write_time();      //把时间写进去
    }
    if(menu_1 == 2)           // 设置年月日
    {
        if(menu_2 == 1)          //设置日
        {
            if(key_can == 3)    //加键 
            {
                ri+=0x01;        //设置日加1
                if((ri & 0x0f) >= 0x0a)
                    ri = (ri & 0xf0) + 0x10;
                if(ri >= 0x32)
                    ri = 0;            
            }        
            if(key_can == 4)    //减键       
            {
                if(ri == 0x01)
                    ri = 0x32;
                if((ri & 0x0f) == 0x00)
                    ri = (ri | 0x0a) - 0x10;
                ri -- ;            //设置日减1
            }
        }
        if(menu_2 == 2)          //设置月
        {
            if(key_can == 3)    //加键 
            {
                yue+=0x01;        //设置月加1
                if((yue & 0x0f) >= 0x0a)
                    yue = (yue & 0xf0) + 0x10;
                if(yue >= 0x13)
                    yue = 1;
            }        
            if(key_can == 4)    //减键       
            {
                if(yue == 0x01)
                    yue = 0x13;
                if((yue & 0x0f) == 0x00)
                    yue = (yue | 0x0a) - 0x10;
                yue -- ;        //设置月减1            
            }            
        }
        if(menu_2 == 3)          //设置年
        {
            if(key_can == 3)    //加键 
            {
                nian+=0x01;        //设置年加1 
                if((nian & 0x0f) >= 0x0a)
                    nian = (nian & 0xf0) + 0x10;
                if(nian >= 0x9a)
                    nian = 1;
            }        
            if(key_can == 4)    //减键       
            {
                if(nian == 0x01)
                    nian = 0x9a;
                if((nian & 0x0f) == 0x00)
                    nian = (nian | 0x0a) - 0x10;
                nian -- ;        //设置年减1
            }        
        }
        write_time();      //把时间写进去
    }    
    if(menu_1 == 3)           // 设置星期 闹钟的开和关
    {
        if(menu_2 == 1)          //设置星期
        {
            if(key_can == 3)    //加键 
            {
                week+=0x01;        //设置星期加1 
                if((week & 0x0f) >= 0x0a)
                    week = (week & 0xf0) + 0x10;
                if(week >= 0x08)
                    week = 1;
            }        
            if(key_can == 4)    //减键       
            {
                if(week == 0x01)
                    week = 0x08;
                if((week & 0x0f) == 0x00)
                    week = (week | 0x0a) - 0x10;
                week -- ;        //设置星期减1
            }        
        }
        if(menu_2 == 2)          //设置闹钟的开和关
        {
            if((key_can == 4) || (key_can == 3))    //加
            open1 ++;
            if(open1 >= 2)
                open1 = 0;
         }
        write_time();      //把时间写进去
    }
    if(menu_1 == 4)           // 设置 闹钟
    {
        if(menu_2 == 1)          //设置分
        {
            if(key_can == 3)    //加键 
            {
                fen1+=0x01;        //设置闹钟分加1
                if((fen1 & 0x0f) >= 0x0a)
                    fen1 = (fen1 & 0xf0) + 0x10;
                if(fen1 >= 0x60)
                    fen1 = 0;
            }    
            if(key_can == 4)    //减键       
            {
                if(fen1 == 0x00)
                    fen1 = 0x5a;
                if((fen1 & 0x0f) == 0x00)
                    fen1 = (fen1 | 0x0a) - 0x10;
                fen1 -- ;        //设置闹钟分减1        
            }
        }
        if(menu_2 == 2)          //设置时
        {
            if(key_can == 3)    //加键 
            {
                shi1+=0x01;        //设置闹钟时加1
                if((shi1 & 0x0f) >= 0x0a)
                    shi1 = (shi1 & 0xf0) + 0x10;
                if(shi1 >= 0x24)
                    shi1 = 0;
            }        
            if(key_can == 4)    //减键       
            {
                if(shi1 == 0x00)
                    shi1 = 0x5a;
                if((shi1 & 0x0f) == 0x00)
                    shi1 = (shi1 | 0x0a) - 0x10;
                shi1 -- ;        //设置闹钟时减1
            }        
        }
         write_time();      //把时间写进去
    }

}


/************菜单处理函数****************/
void menu_dis()
{
    if((menu_1 == 1))     //选设置时 分 秒
    {        
        dis_smg[0] = smg_du[miao % 16];   //显示秒
        dis_smg[1] = smg_du[miao / 16];   //
        dis_smg[2] = 0x7f; 
        dis_smg[3] = smg_du[fen % 16];   //显示分
        dis_smg[4] = smg_du[fen / 16];   //
        dis_smg[5] = 0x7f; 
        dis_smg[6] = smg_du[shi % 16];   //显示秒
        dis_smg[7] = smg_du[shi / 16];   //
      }
    if((menu_1 == 2))     //选设置年  月  日
    {        
        dis_smg[0] = smg_du[ri % 16];   //显示日
        dis_smg[1] = smg_du[ri / 16];   //
        dis_smg[2] = 0xfe; 
        dis_smg[3] = smg_du[yue % 16];   //显示月
        dis_smg[4] = smg_du[yue / 16];   //
        dis_smg[5] = 0xfe; 
        dis_smg[6] = smg_du[nian % 16];   //显示年
        dis_smg[7] = smg_du[nian / 16];   //
      }
    if((menu_1 == 3))     //设置星期 和 闹钟的开和关
    {
        dis_smg[0] = smg_du[week % 16];   //显示星期 
        dis_smg[1] = smg_du[week / 16];   //
        dis_smg[2] = 0x7f; 
        if(open1 == 1)       //开闹钟
        {
            dis_smg[3] = 0xb0;       //OPEN
            dis_smg[4] = 0x64;   
            dis_smg[5] = 0x70; 
            dis_smg[6] = 0xa0;   
        }else 
        {
            dis_smg[3] = 0x74;       //OFF
            dis_smg[4] = 0x74;   
            dis_smg[5] = 0xa0; 
            dis_smg[6] = 0xFF;   
        }
      }
    if(menu_1 == 4)     //选设置时 分 秒
    {
        dis_smg[0] = 0xff;   //
        dis_smg[1] = 0xff;   //
        dis_smg[2] = smg_du[fen1 % 16];   //显示分
        dis_smg[3] = smg_du[fen1 / 16];   //
        dis_smg[4] = 0x7f; 
        dis_smg[5] = smg_du[shi1 % 16];   //显示秒
        dis_smg[6] = smg_du[shi1 / 16];   //
        dis_smg[7] = 0xff; 
      }

}

/*************闹钟报警函数***************/
void clock_dis()
{
     if(flag_100ms == 1)          //100ms执行一次
    {
        flag_100ms = 0;
        if(open1 == 1)    //如果闹钟打开
        {
            if((miao == 0) && (fen == fen1) && (shi == shi1)) 
            {        
                flag_beep_en = 1;    //有报警 打开蜂鸣器响的标志位                
            }        
            if(flag_beep_en == 1)    //闹钟以被打开
            {
                 beep = ~beep;       //蜂鸣器叫3秒
            }
            if((miao == 0) && (fen == fen1+1) && (shi == shi1)) 
            {        
                flag_beep_en = 0;    //1分钟后关闭闹钟            
            }        
        }    
    }
}

/*************定时器0初始化程序***************/
void time_init()      
{
    EA   = 1;           //开总中断
    TMOD = 0X01;      //定时器0、工作方式1
    ET0  = 1;          //开定时器0中断 
    TR0  = 1;          //允许定时器0定时
}

/*************时钟显示***************/
void xianshi_ds1302()
{
    uchar value;
     value ++;
    if(value <= 5*2)  //2秒
    {
        dis_smg[0] = smg_du[miao % 16];   //显示秒
        dis_smg[1] = smg_du[miao / 16];   //
        dis_smg[2] = 0x7f; 
        dis_smg[3] = smg_du[fen % 16];   //显示分
        dis_smg[4] = smg_du[fen / 16];   //
        dis_smg[5] = 0x7f; 
        dis_smg[6] = smg_du[shi % 16];   //显示秒
        dis_smg[7] = smg_du[shi / 16];   //
    }
    else if(value <= 5*4)  //2秒
    {
        dis_smg[0] = smg_du[ri % 16];   //显示日 
        dis_smg[1] = smg_du[ri / 16];   //
        dis_smg[2] = 0x7f; 
        dis_smg[3] = smg_du[yue % 16];   //显示月
        dis_smg[4] = smg_du[yue / 16];   //
        dis_smg[5] = 0x7f; 
        dis_smg[6] = smg_du[nian % 16];   //显示年
        dis_smg[7] = smg_du[nian / 16];   //
    }
    else if(value <= 5*6)  //2秒
    {
        dis_smg[0] = smg_du[week % 16];   //显示星期
        dis_smg[1] = smg_du[week / 16];   //

    }
    else 
        value = 0;
}

/*****************主函数********************/
void main()
{    
    uchar ii;
    beep = 0;                        //开机叫一声   
    delay_1ms(150);
    P0 = P1 = P2 = P3 = 0xff;        //单片机IO口初始化为1
     time_init();   //定时器初始化
    while(1)
    {
        key();             //按键程序
        if(flag_beep_en == 0)  //只有闹钟关了的时候才能进入设置
            key_with();    
        else 
        {
            flag_beep_en = 0;     //按下任意键可关闭闹钟
            beep = 1;
        }

        if(flag_200ms == 1)
        {    
            flag_200ms = 0;
            read_time();          //读时间
            xianshi_ds1302();   //显示时钟
        }
        menu_dis();      //设置的对应的显示处理
        clock_dis();  //闹钟报警函数

        P0 = 0xff;             //消隐 
        P2 = smg_we[ii];              //位选
        P0 = dis_smg[ii];         //段选         
        ii++;
        if(ii >= 8)
            ii = 0;    
        delay_1ms(1);

    }
}

/*************定时器0中断服务程序***************/
void time0_int() interrupt 1
{    
    uint value;
    TH0 = 0xF8;
    TL0 = 0x30;     // 2ms     12M

    value ++;
    if((value % 50) == 0)     //100ms  
        flag_100ms = 1;     
    if(value % 100 == 0)  
    {     
        flag_200ms = 1;
    }
}

仿真图(proteus)

51单片机计时器代码,单片机,51单片机

仿真图(CAD)

51单片机计时器代码,单片机,51单片机

 PCB图:

51单片机计时器代码,单片机,51单片机

红线所接的是跳线

常见问题:

 数码管采用的是什么扫描方式?

一位数码管的设计就是采用静态扫描的方式,因为一位数码管是8个段选1个位选,如果采用动态,那就是得用9个IO口,而且程序也比较麻烦,如果选用静态那么位选接电源或地(共阳接电源,共阴接地),段选接IO口,就可以控制显示了,这样只用8个IO口就ok,而且程序比较简单。多位一体的数码管只能用动态扫描的方式,因为硬件本身就将每个位的段都接到一起了,所以只能动态控制了。

蜂鸣器或继电器的驱动三极管为什么选用pnp型的(9012、8550),而不是npn型的(9013、8050)?

因为单片机刚一上电的时候所有的IO口会有一个短暂的高电平。如果选用npn型的,即使程序上将IO口拉低,蜂鸣器或继电器也会响一小下或吸合一下,为了避免这种情况发生,就选用pnp型的。因为我们想控制蜂鸣器或继电器工作单片机的IO口要低电平,这样就避免了,因为我们不可能刚一通电就让蜂鸣器响或继电器吸合。避免了不必要的麻烦。

液晶三脚接的电阻是而不是可调电阻

经过查阅资料得知(买液晶时给的资料),液晶3脚是灰度调节引脚,灰度正常时是0.5~1V左右,用可调电阻其他就是电阻分压的原理得到的电压,而我们直接用的是电阻也是可以得到正常显示的电压的。

为什么继电器吸合或风扇转动时,液晶屏幕会变暗?

从问题5中可以了解大概,就是液晶的灰度是电压控制的,当继电器吸合或风扇转动时,需要的电流较大,而我们采用的电源线或电池盒供电会有一定的压降。这样液晶的3脚采集的电压就高了。所以灰度就不合适了。解决的办法是,电源尽量用好一点的,或换粗一点的电源线供电(主要的压降都在电源线上)。

超声波测距模块的工作原理?

一个控制口发一个10US以上的高电平,就可以在接收口等待高电平输出.一有输出就可以开定时器计时,当此口变为低电平时就可以读定时器的值,此时就为此次测距的时间,方可算出距离.如此不断的周期测,就可以达到你移动测量的值了。

你的程序是怎么下载进去的?

STC单片机程序下载:

 这个STC_ISP软件是串口下载的,加载程序文件夹中的.hex文件链接好下载器就可以下载了(首先下载器的驱动得装好)

AT的单片机怎么下载

   AT单片机要用专门的下载器才能下载

有些电阻的阻值是怎么算出来的?

比如是LED串联的分压电阻,计算方法是:R=U/I

Led工作电压是3V左右,那么电阻的电压就是(供电电压-3v)=2v

Led点亮的电流是4~20ma,那么电阻的电流也是4~20ma

这样电阻就是2除以0.004~0.02=100~500Ω

但是实际使用的时候用100~500Ω,led就太亮了,很容易烧坏,所以就适当的加大了电阻。

晶振为什么选用12M?

12M是比较常用的晶,51单片机是12分频的,如果选用12M晶振,如果是单指令周期的语句,刚好是1us,其他语句正好是1us的整数倍。很轻松算出每个语句用了多长时间。

晶振为什么选用11.0592M?

11.0592比较常应用在串口通信和红外遥控电路中。

11.0592M是因为在进行通信时,12M频率进行串行通信不容易实现标准的波特率,比如9600,4800,而11.0592M计算时正好可以得到,因此在有通信接口的单片机中,一般选11.0592M计算一下就知道了。如我们要得到9600 的波特率,晶振为11.0592M 和12M,定时器1为模式2,SMOD 设为1,分别看看那所要求的TH1 为何值。代入公式:11.0592M 9600=(2÷32)×((11.0592M/12)/(256-TH1)) TH1=25012M 9600=(2÷32)×((12M/12)/(256-TH1))TH1≈249.49上面的计算可以看出使用12M 晶体的时候计算出来的TH1 不为整数,而TH1 的值只能取整数,这样它就会有一定的误差存在不能产生精确的9600 波特率。

比如做GSM的设计时,用12M就是不可行的,就得用11.0592M。

定时器的初值是怎么算的?

我们一般采用的是50ms的定时,那样20个50ms就是1s。至于初值怎么算,课本上刚学的时候就交了,可以自己看下,如果看了会发现我们的初值好像和课本上的不一样,那是因为我们是用软件算的。计算初值有好多软件,可以找度娘。软件很方便,动动手就可以了哦。

仿真图好像和实物图有差别呢?

仿真图就是一个模拟用的,和实际效果是有点差别的,仿真中没有晶振电路和复位电路都是可以工作的,焊接是按照原理图来的而不是仿真。文章来源地址https://www.toymoban.com/news/detail-739644.html

到了这里,关于基于52单片机的电子时钟(原理图,代码)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 基于单片机的6位电子时钟

    点击链接获取Keil源码与Project Backups仿真图 https://download.csdn.net/download/qq_64505944/87413394 源码获取 近年来随着科技的飞速发展,人们对单片机技术的应用正在不断加深。单品微型计算机简称单片机,是典型的嵌入式微控制器,又称单片微控制器,它不是完成某个逻辑功能的芯片,

    2024年02月07日
    浏览(41)
  • 单片机课设 - 电子时钟 (仿真,仿真代码,实验板代码)

    1. 主要器件 : C51单片机、8位LED数码管(共阴极)… 2. 仿真图如下: 3. 主要特点 1. 24进制显示 2. 最下方三个按钮分别控制时、分、秒 上述代码包含的主要内容: 1. T1定时方式1,用到T1中断函数 2. 每50ms溢出一次,一共20次为 1s 记一次数 3. 按键知识,消抖动... 4. 移位知识,_c

    2024年02月11日
    浏览(38)
  • 基于AT89C52单片机的电子秒表设计与仿真

    点击链接获取Keil源码与Project Backups仿真图: https://download.csdn.net/download/qq_64505944/87755619?spm=1001.2014.3001.5503 源码获取 主要内容: 本设计以AT89C52单片机为核心,采用常用电子器件设计,包括电源开关、按键、数码管显示、LCD1602液晶。将软、硬件有机的结合起来,使得系统能够

    2024年02月02日
    浏览(69)
  • 基于AT89S52单片机的多功能电子万年历

    基于AT89S52单片机的多功能电子万年历的硬件结构和软硬件设计方法。本设计由数据显示模块、温度采集模块、时间处理模块和调整设置模块四个模块组成。系统以AT89S52单片机为控制器,以串行时钟日历芯片DS1302记录日历和时间,它可以对年、月、日、时、分、秒进行计时,

    2024年02月03日
    浏览(81)
  • 基于AT89C52单片机的简易电子琴设计与仿真

    点击链接获取Keil源码与Project Backups仿真图: https://download.csdn.net/download/qq_64505944/87853299?spm=1001.2014.3001.5503 源码获取 主要内容: 本设计是基于51系列的单片机进行的设计,利用所给键盘的八个键,能够发出8个不同的音调,并且要求按下按键发声,松开延时一段时间停止,中间

    2024年02月04日
    浏览(50)
  • 基于51单片机、DS1302时钟模块的电子闹钟设计

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 提示:以下是本篇文章正文内容,下面案例可供参考 DS1302 是美国DALLAS公司推出的一种高性能、低功耗、带RAM的实时时钟电路,它可以对年、月、日、周、时、分、秒进行计时,具有闰年补偿功能,工作

    2024年02月02日
    浏览(70)
  • 基于AT89C51单片机的电子时钟设计

    点击链接获取Keil源码与Project Backups仿真图: https://download.csdn.net/download/qq_64505944/87695258?spm=1001.2014.3001.5503 源码获取 主要内容: 1.设计出电子数字钟的电路,并用protus进行仿真画出对应的电路图 2.设计出电子数字钟的源程序,并用Keil进行编辑生成HEX文件 3.在protus中进行测试。

    2024年02月09日
    浏览(67)
  • 基于AT89C51单片机的电子时钟设计与仿真

    点击链接获取Keil源码与Project Backups仿真图: https://download.csdn.net/download/qq_64505944/87779867?spm=1001.2014.3001.5503 源码获取 主要内容: 使用DS1302芯片作为计时设备,用6个7段LED数码管或者LCD162作为显示设备,实现时钟功能; 基本要求: (1)可以分别设定小时、分钟和秒,复位后时

    2024年02月06日
    浏览(54)
  • 单片机原理与应用课程设计-基于51单片机的时钟日历

    摘 要 本课程设计是基于51单片机的日历时钟设计。作为嵌入式系统中常用的控制器,单片机在各种电子设备和系统中广泛应用。日历时钟作为一个常见的功能模块,在现代生活中具有重要意义。因此,设计一个基于51单片机的日历时钟,不仅有助于我们掌握单片机编程技术和

    2024年02月20日
    浏览(72)
  • 51单片机电子时钟(C语言)

     全部硬件电路分为四大部分: 控制模块51单片机; 显示模块LCD1602,由P0口控制; 计时模块DS1302,由P1口控制; 输入按键,由P3口控制。         实际设计硬件电路时应考虑到51单片机的电源、复位电路以及外接晶振,时钟芯片DS1302的备用电源等。 从1302的寄存器中读取数据

    2024年02月07日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包