找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2281|回复: 0
打印 上一主题 下一主题
收起左侧

单片机4x4键盘,数码管显示时间,闹钟设置 Proteus仿真程序

[复制链接]
跳转到指定楼层
楼主
仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)


*键时钟和闹钟光标
#键用于控制闹钟和时钟切换
A/B/C/D键预留,暂时控制LED2灯
数字键用于设置闹钟和时钟时间

单片机源程序如下:
#include <reg52.h>

#define uchar unsigned char
#define uint unsigned int


unsigned char ReturnKeyValue=0;
unsigned char KeyN=0;

#define WE8 0xfe
#define WE7 0xfd
#define WE6 0xfb
#define WE5 0xf7
#define WE4 0xef
#define WE3 0xdf
#define WE2        0xbf
#define WE1 0x7f


//sbit dula = P2^6;
//sbit wela = P2^7;

sbit BEEP =P3^0;
sbit LED1 =P3^2;
sbit LED2 = P3^3;

unsigned char CurrentSec_ge=0;
unsigned char CurrentSec_shi=0;
unsigned char CurrentMin_ge=0;
unsigned char CurrentMin_shi=0;
unsigned char CurrentHour_ge=0;
unsigned char CurrentHour_shi=0;


unsigned char SetClockSec_ge=0;
unsigned char SetClockSec_shi=0;
unsigned char SetClockMin_ge=0;
unsigned char SetClockMin_shi=0;
unsigned char SetClockHour_ge=0;
unsigned char SetClockHour_shi=0;

unsigned char ChangeTimeCount =0;
uint TimeKCount         =0;
uint TimeGCount  =0;
uint TimeKflag   =0;
uint num = 0;
uint flag;
uint cflag;

uchar code table[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
uchar code table1[] = {0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x80};

uint rsec = 0, rmin = 0, rhour = 0;
uint csec = 0, cmin = 1, chour = 0;

void clock();
void delay(uint z);
void displaysec(uint sec);
void displaymin(uint min);
void displayhour(uint hour);

unsigned char AlarmTimeCount =0;

void Alarmclock()
{
        if(rsec == csec && rmin == cmin && rhour == chour)
        {
      BEEP =0;
      LED1 =0;
          AlarmTimeCount=200;
        }
}
void delay(uint z)
{
        uint x,y;
        for(x=0;x<z;x++)
                for(y=0;y<110;y++);
}

void displaysec(uint sec)
{  
        P2 = WE1;
        if((KeyN==1)||(KeyN==7))
        {
                if(TimeKflag==1)
                {
                          P0 = 0xff;
                }
                else
                {
                           P0 = table[sec%10];
                }
        }
        else
        {
                  P0 = table[sec%10];
        }
        delay(3);
        P2 = WE2;
        if((KeyN==2)||(KeyN==8))
        {
        if(TimeKflag==1)
        {
                  P0 = 0xff;
        }
        else
        {
        P0 = table[sec/10];
        }
        }
        else
        {
          P0 = table[sec/10];
        }
        delay(3);
        P2 = WE3;
        P0 = 0xBF;
        delay(3);
        
}
void displaymin(uint min)
{

         P2 = WE4;
         if((KeyN==3)||(KeyN==9))
        {
                if(TimeKflag==1)
                {
                          P0 = 0xff;
                }
                else
                {
                            P0 = table[min%10]- 0x80;
                }
        }
        else
        {
                   P0 = table[min%10]- 0x80;
        }

        delay(5);
        P2 = WE5;
         if((KeyN==4)||(KeyN==10))
        {
                if(TimeKflag==1)
                {
                          P0 = 0xff;
                }
                else
                {
                                    P0 = table[min/10] ;
                }
        }
        else
        {
                           P0 = table[min/10] ;
        }

        delay(5);
        P2 = WE6;
        P0 = 0xBF;
        delay(3);
}


void displayhour(uint hour)
{
        P2 = WE7;
         if((KeyN==5) ||(KeyN==11))
        {
                if(TimeKflag==1)
                {
                          P0 = 0xff;
                }
                else
                {
                            P0 = table[hour%10] - 0x80;
                }
        }
        else
        {
                           P0 = table[hour%10] - 0x80;
        }
        
        delay(3);
        P2 = WE8;
        if((KeyN==6)||(KeyN==12))
        {
                if(TimeKflag==1)
                {
                          P0 = 0xff;
                }
                else
                {
                            P0 = table[hour/10];
                }
        }
        else
        {
                           P0 = table[hour/10];
        }
        
        delay(3);
}



  /****************************************************************************
函数功能:键盘扫描子程序
入口参数:
出口参数:
****************************************************************************/

unsigned char keyscan(void)
{  
         unsigned KeyValue =0;
        unsigned char n=0;

        //扫描第一行
        P1=0xfe;
        n=P1;
        n&=0xf0;
        if(n!=0xf0)
        {
                 P1=0xfe;
                 n=P1;
                 n&=0xf0;
                 if(n!=0xf0)
                {
                  delay(10);
                           switch(n)
                        {

                    case(0xe0):KeyValue=1;break;  //
                    case(0xd0):KeyValue=2;break;  //
                    case(0xb0):KeyValue=3;break;        //
                    case(0x70):KeyValue=13;break;        //
                    }
                   }
         }
        //扫描第二行
        P1=0xfd;
        n=P1;
        n&=0xf0;
        if(n!=0xf0)
        {
                  P1=0xfd;
                  n=P1;
                  n&=0xf0;
                  if(n!=0xf0)
                {
                    delay(10);
                          switch(n)
                        {
                        case(0xe0):KeyValue=4;break;          //
                    case(0xd0):KeyValue=5;break;         //         
                    case(0xb0):KeyValue=6;break;
                    case(0x70):KeyValue=14;break;
                    }
                   }
         }
        //扫描第三行
        P1=0xfb;
        n=P1;
        n&=0xf0;
        if(n!=0xf0)
        {

                  P1=0xfb;
                  n=P1;
                  n&=0xf0;
                  if(n!=0xf0)
                {
                delay(10);
                           switch(n)
                        {
                    case(0xe0):KeyValue=7;break;
                    case(0xd0):KeyValue=8;break;
                           case(0xb0):KeyValue=9;break;
                    case(0x70):KeyValue=15;break;
                    }
                   }
         }
        //扫描第四行
        P1=0xf7;
        n=P1;
        n&=0xf0;
        if(n!=0xf0)
        {
            
                  P1=0xf7;
                  n=P1;
                  n&=0xf0;
                  if(n!=0xf0)
                {
                   delay(10);
                           switch(n)
                        {
                    case(0xe0):KeyValue=11;break; //*键
                    case(0xd0):KeyValue=10;break; //0键
                    case(0xb0):KeyValue=12;break; //#键
                    case(0x70):KeyValue=16;break;
                    }
                   }
         }
        return         KeyValue;
}



void main ()
{
        EA = 1;
        ET1 = 1;
        TMOD = 0x10;
        TR1 = 1;
         TH1 = (65536-46071)/256;
        TL1 = (65536-46071)%256;

        KeyN=0;
        P1=0x0f;
               
        while(1)
        {        

            Alarmclock();
            ReturnKeyValue = keyscan();
        
                if(ReturnKeyValue!=0)
                {
                      delay(200);
                                switch(ReturnKeyValue)
                                {
                                
                                 case 11:
                                 {
                                    TimeKCount         =10;
                    TimeGCount  =0;
                    TimeKflag   =1;        
                                         KeyN++;
                                        if(KeyN>12)
                                        {
                                         KeyN=0;
                                        }
                                 }
                                 break;
                                 case 12:          //显示闹钟时间
                                 {
                                    ChangeTimeCount++;
                                 }
                                 break;

                                  case 13:          // 没用到 可以用于点亮指示灯
                                   case 14:          //
                                   case 15:          // 没用到 可以用于点亮指示灯
                                   case 16:          //
                                 {
                                    LED2=~LED2;

                                 }
                                 break;
                                 

                                }
                if(ReturnKeyValue<=10)
                {
                 switch(KeyN)
                  {

                        case 1:
                                  if(ReturnKeyValue==10)
                                  {
                                   rsec=0;
                                   CurrentSec_ge =        0;
                                   }
                                   else
                                   {
                                   rsec =  ReturnKeyValue;
                                   CurrentSec_ge =        ReturnKeyValue;
                                   }

                                   
                        break;
                        case 2:
                                   if(ReturnKeyValue==10)
                                  {
                                   rsec=0*10+CurrentSec_ge;
                                   }
                                   else
                                   {
                                           if(ReturnKeyValue<6)
                                           {
                                            rsec =  ReturnKeyValue*10+CurrentSec_ge;
                                           }
                                   }

                        break;
                        case 3:
                                 
                                if(ReturnKeyValue==10)
                                 {
                                      rmin=0;
                                      CurrentMin_ge=0;
                                   }
                                   else
                                   {
                                      rmin =  ReturnKeyValue;
                                    CurrentMin_ge   =  ReturnKeyValue;
                                   }

                                 
                        break;
                        case 4:
                                          if(ReturnKeyValue==10)
                                   rmin=0*10+CurrentMin_ge;
                                   else
                                   {
                                           if(ReturnKeyValue<6)
                                           {
                                            rmin =  ReturnKeyValue*10+  CurrentMin_ge;
                                           }
                                   }

                        break;
                        case 5:
                                        if(ReturnKeyValue==10)
                                        {
                                     rhour=0;
                                     CurrentHour_ge=0;
                                   }
                                   else
                                   {
                                           //if(ReturnKeyValue<=4)
                                           {
                                            rhour =  ReturnKeyValue;
                                                CurrentHour_ge =  ReturnKeyValue;

                                           }
                                   }
                                   

                        break;
                        case 6:
                               if(ReturnKeyValue==10)
                                   {
                                     rhour=CurrentHour_ge;
                                   }
                                   else
                                   {
                                    if(ReturnKeyValue<=2)
                                           {
                                            
                                          
                                       if(CurrentHour_ge>=4)
                                                {
                                                  if(ReturnKeyValue<=1)
                                               rhour =  ReturnKeyValue*10+CurrentHour_ge;
                                                }
                                                else
                                                {
                                                  rhour =  ReturnKeyValue*10+CurrentHour_ge;
                                                }
                                           }
                                   }
                        break;

                                case 7:
                                  if(ReturnKeyValue==10)
                                  {
                                   csec=0;
                                   SetClockSec_ge =        0;
                                   }
                                   else
                                   {
                                   csec =  ReturnKeyValue;
                                   SetClockSec_ge =        ReturnKeyValue;
                                   }

                                   
                        break;
                        case 8:
                                   if(ReturnKeyValue==10)
                                  {
                                   csec=0*10+SetClockSec_ge;
                                   }
                                   else
                                   {
                                           if(ReturnKeyValue<6)
                                           {
                                            csec =  ReturnKeyValue*10+SetClockSec_ge;
                                           }
                                   }

                        break;
                        case 9:
                                 
                                         if(ReturnKeyValue==10)
                                         {
                                      cmin=0;
                                      SetClockMin_ge=0;
                                   }
                                   else
                                   {
                                   cmin =  ReturnKeyValue;
                                    SetClockMin_ge   =  ReturnKeyValue;
                                   }

                                 
                        break;
                        case 10:
                                          if(ReturnKeyValue==10)
                                   cmin=0*10+SetClockMin_ge;
                                   else
                                   {
                                           if(ReturnKeyValue<6)
                                           {
                                            cmin =  ReturnKeyValue*10+  SetClockMin_ge;
                                           }
                                   }

                        break;
                        case 11:
                                        if(ReturnKeyValue==10)
                                        {
                                     chour=0;
                                     SetClockHour_ge=0;
                                   }
                                   else
                                   {
                                           //if(ReturnKeyValue<=4)
                                           {
                                            chour =  ReturnKeyValue;
                                                SetClockHour_ge =  ReturnKeyValue;

                                           }
                                   }
                                   

                        break;
                        case 12:
                               if(ReturnKeyValue==10)
                                   {
                                     chour=SetClockHour_ge;
                                   }
                                   else
                                   {
                                    if(ReturnKeyValue<=2)
                                           {
                                            
                                          
                                       if(SetClockHour_ge>=4)
                                                {
                                                  if(ReturnKeyValue<=1)
                                               chour =  ReturnKeyValue*10+SetClockHour_ge;
                                                }
                                                else
                                                {
                                                  chour =  ReturnKeyValue*10+SetClockHour_ge;
                                                }
                                           }
                                   }
                        break;


                  }
                 }        
            }
    }
}
余下篇幅文件里下 矩阵键盘数码管闹钟.zip (165.79 KB, 下载次数: 33)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶 踩
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表