单片机按键反应太慢,感觉是延时函数太多,如何改中断法

/***************************************************************************************/

#include "reg52.h"                         //此文件中定义了单片机的一些特殊功能寄存器
#include "ds1302.h"
#include "temp.h"
#include "lcd.h"
#include "eeprom.h"

sbit k1 = P3^0;                          //按键
sbit k2 = P3^1;                        
sbit k3 = P3^2;
sbit k4 = P3^3;

sbit lcdled = P2^4;                          //lcd背光
sbit beep = P1^4;                        //蜂鸣器

unsigned int ti=0,alarm=0;       //修改第几个时间参数 、修改第几个闹钟参数
unsigned char alarm_hour=0x12,alarm_min=0x00;         //闹钟时、分参数

enum Mode                                //定义枚举、三种模式
{
        DISPLAYDATA,MODIFYDATA,SETALARMCLOCK,NONE,ALARMCLOCK
}mode;

enum Alarmswitch         //定义闹钟开关
{
        OFF,ON
}alarmswitch;

/*********延时函数***********/                  
void delay(unsigned int t)         //短延时
{
         while(t--);
}
void delay_ms(unsigned int t)        //毫秒延时
{
        unsigned int a,b;
        for(a=0;a<t;a++)
        for(b=0;b<120;b++);
}

/********显示日期、时间、星期***********/
void display_data(void)
{
        LcdWriteCom(0x80);
        LcdWritestr("20");        
        LcdWriteData(TIME[6]/16+0x30);          //年
        LcdWriteData(TIME[6]%16+0x30);
        LcdWriteData('-');
        LcdWriteData(TIME[4]/16+0x30);          //月
        LcdWriteData(TIME[4]%16+0x30);
        LcdWriteData('-');
        LcdWriteData(TIME[3]/16+0x30);          //日
        LcdWriteData(TIME[3]%16+0x30);

        LcdWritestr("  ");
        switch(TIME[5])                                           //显示星期
        {               
                case 0:LcdWritestr("Mon"); break;
                case 1:LcdWritestr("Tue"); break;
                case 2:LcdWritestr("Wed"); break;
                case 3:LcdWritestr("Thu"); break;
                case 4:LcdWritestr("Fri"); break;
                case 5:LcdWritestr("Sat"); break;
                case 6:LcdWritestr("Sun"); break;
        }
        if(alarmswitch==ON)LcdWriteData('.');
        else LcdWriteData(' ');

        LcdWriteCom(0xC0);
        LcdWriteData(' ');
        LcdWriteData(TIME[2]/16+0x30);          //时
        LcdWriteData(TIME[2]%16+0x30);
        LcdWriteData(':');
        LcdWriteData(TIME[1]/16+0x30);          //分
        LcdWriteData(TIME[1]%16+0x30);
        LcdWriteData(':');
        LcdWriteData(TIME[0]/16+0x30);          //秒
        LcdWriteData(TIME[0]%16+0x30);
        LcdWritestr(" ");
}

/*********显示温度***********/
void displaytemp(int temp)          //显示温度
{
           float tp;  
        if(temp< 0)                        
          {
                LcdWriteCom(0xca);
                LcdWriteData('-');
                temp=temp-1;
                temp=~temp;
                tp=temp;
                temp=tp*0.0625*100+0.5;        

          }
         else
          {                        
                LcdWriteCom(0xca);
                LcdWriteData('+');
                tp=temp;
                temp=tp*0.0625*100+0.5;        
        }
        LcdWriteData(temp % 10000 / 1000 + 0x30);
        LcdWriteData(temp % 1000 / 100  + 0x30);
        LcdWriteData('.');
        LcdWriteData(temp % 100 / 10 + 0x30);
        LcdWriteData(temp % 10 + 0x30);
}


/*******************************************************************************
* 函 数 名         : keypros
* 函数功能                   : 按键处理函数，判断按键K1是否按下
*******************************************************************************/
void keypros()                   //初始页面按键检测
{
        if(k1 == 0)                           //切换模式
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k1==0)         //再次判断按键是否按下
                {
                        mode+= 1;if(mode == 3)mode = DISPLAYDATA;
                }
                while(k1 == 0);
        }
        if(k2 == 0)                          //蜂鸣器测试
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k2==0)         //再次判断按键是否按下
                {
                        beep = !beep;  
                }
                while(k2 == 0);
        }
        if(k3 == 0)                   //背光灯测试
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k3==0)         //再次判断按键是否按下
                {
                        lcdled = !lcdled;  
                }
                while(k3 == 0);
        }
        if(k4 == 0)                        //背光灯测试
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k4==0)         //再次判断按键是否按下
                {
                        alarmswitch=!alarmswitch;  
                }
                while(k4 == 0);
        }               
}

/*************修改时间************/
void modify(void)
{
        display_data();
        if(k1 == 0)                        //切换模式
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k1==0)         //再次判断按键是否按下
                {
                        mode+= 1;if(mode == 3)mode = DISPLAYDATA;
                }

                while(k1 == 0);
        }
        if(k2 == 0)                   //选择修改参数
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k2==0)         //再次判断按键是否按下
                {
                        ti++;
                        if(ti == 8)ti=0;
                }
                while(k2 == 0);
        }
        
        switch(ti)                                   //选择进入修改参数
        {
                case 0:
                                                delay_ms(20);
                                                if(k4==0 | k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4==0 | k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[0]=0;
                                                        }
                                                        while(k4 == 0 | k3==0);
                                                }
                                                LcdWriteCom(0xc7);
                                                LcdWritestr("  ");
                                                break;    //?
                case 1:
                                                delay_ms(20);
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[1]++;
                                                           if(TIME[1]%16 == 0x0a)
                                                           {
                                                                           TIME[1] += 16;
                                                                        TIME[1] &= 0xf0;
                                                           }if(TIME[1]==0x60)TIME[1]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[1]--;
                                                           if(TIME[1]%16==0x0f && TIME[1]!=0xff)
                                                           {
                                                                        TIME[1] &= 0xf9;
                                                           }
                                                           if(TIME[1]==0xff)TIME[1]=0x59;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0xc4);
                                                LcdWritestr("  ");
                                                break;    //?
                case 2:
                                                delay_ms(20);
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[2]++;
                                                           if(TIME[2]%16 == 0x0a)
                                                           {
                                                                           TIME[2] += 16;
                                                                        TIME[2] &= 0xf0;
                                                           }if(TIME[2]==0x24)TIME[2]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[2]--;
                                                           if(TIME[2]%16==0x0f && TIME[2]!=0xff)
                                                           {
                                                                        TIME[2] &= 0xf9;
                                                           }
                                                           if(TIME[2]==0xff)TIME[2]=0x23;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0xc1);
                                                LcdWritestr("  ");
                                                break;    //?
                case 3:
                                                delay_ms(10);
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[3]++;
                                                           if(TIME[3]%16 == 0x0a)
                                                           {
                                                                           TIME[3] += 16;
                                                                        TIME[3] &= 0xf0;
                                                           }if(TIME[3]==0x32)TIME[3]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[3]--;
                                                           if(TIME[3]%16==0x0f && TIME[3]!=0xff)
                                                           {
                                                                        TIME[3] &= 0xf9;
                                                           }
                                                           if(TIME[3]==0xff)TIME[3]=0x31;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0x88);
                                                LcdWritestr("  ");
                                                break;         //日
                case 4:
                                       
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[4]++;
                                                           if(TIME[4]%16 == 0x0a)
                                                           {
                                                                           TIME[4] += 16;
                                                                        TIME[4] &= 0xf0;
                                                           }if(TIME[4]==0x13)TIME[4]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[4]--;
                                                           if(TIME[4]%16==0x0f && TIME[4]!=0xff)
                                                           {
                                                                        TIME[4] &= 0xf9;
                                                           }
                                                           if(TIME[4]==0xff)TIME[4]=0x12;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0x85);
                                                LcdWritestr("  ");
                                                break;         //月
                case 5:
                                                
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[5]++;if(TIME[5]==7)TIME[5]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[5]--;if(TIME[5]==0xff)TIME[5]=6;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0x8c);
                                                LcdWritestr("   ");
                                                break;         //周
                case 6:
                                                
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[6]++;
                                                           if(TIME[6]%16 == 0x0a)
                                                           {
                                                                           TIME[6] += 16;
                                                                        TIME[6] &= 0xf0;
                                                           }if(TIME[6]==0xa0)TIME[6]=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           TIME[6]--;
                                                           if(TIME[6]%16==0x0f && TIME[6]!=0xff)
                                                           {
                                                                        TIME[6] &= 0xf9;
                                                           }
                                                           if(TIME[6]==0xff)TIME[6]=0x99;
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0x80);
                                                LcdWritestr("    ");
                                                break;         //年
                case 7:
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           mode=DISPLAYDATA;
                                                           ti=0;
                                                        }
                                                        while(k3==0);
                                                }
                                                LcdWriteCom(0xca);
                                                LcdWritestr("      ");
                                                delay(100);
                                                LcdWriteCom(0xca);
                                                LcdWritestr("<- OK");
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                                   Ds1302Init();                  //时钟初始化
                                                                mode = DISPLAYDATA;    //返回日期
                                                                ti = 0;                                //还原初始修改
                                                        }
                                                        while(k4==0);
                                                }
                                                break;         //年
        }        
}
void setalarmclock(void)        //设置闹钟模式
{
        alarm_hour=byte_read(0x2601);
        alarm_min=byte_read(0x2201);
        alarmswitch=byte_read(0x2401);
        LcdWriteCom(0x80);                         //显示
        LcdWritestr("alarm clock:    ");
        LcdWriteCom(0xc0);
        if(alarmswitch == OFF)LcdWritestr("  OFF    ");
        else LcdWritestr("  ON     ");
        LcdWriteCom(0xc9);
        LcdWriteData(alarm_hour/16+0x30);
        LcdWriteData(alarm_hour%16+0x30);
        LcdWriteData(':');
        LcdWriteData(alarm_min/16+0x30);
        LcdWriteData(alarm_min%16+0x30);
        LcdWritestr("    ");
        
        if(k1 == 0)                         //切换模式
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k1==0)         //再次判断按键是否按下
                {
                        mode+= 1;if(mode == 3)mode = DISPLAYDATA;
                }

                while(k1 == 0);
        }
        if(k2 == 0)                         //选择闹钟修改参数
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k2==0)         //再次判断按键是否按下
                {
                        alarm++;
                        if(alarm == 3)alarm=0;
                }
                while(k2 == 0);
        }
        switch(alarm)                        //选择进入修改参数
        {
                case 0:
                                LcdWriteCom(0xc0);
                                LcdWritestr("      ");
                                if(k3 == 0)                          //控制闹钟开
                                {
                                        delay(1000);   //消除抖动 一般大约10ms
                                        if(k3==0)         //再次判断按键是否按下
                                        {
                                                alarmswitch = ON;
                                                SectorErase(0x2401);
                                                byte_write(0x2401,alarmswitch);
                                        }
                                        while(k3 == 0);
                                }
                                if(k4 == 0)                         //控制闹钟关闭
                                {
                                        delay(1000);   //消除抖动 一般大约10ms
                                        if(k4==0)         //再次判断按键是否按下
                                        {
                                                alarmswitch = OFF;
                                                SectorErase(0x2401);
                                                byte_write(0x2401,alarmswitch);
                                        }
                                        while(k4 == 0);
                                }
                                break;
                case 1:        
                                delay_ms(10);
                                                                                                
                                                if(k3==0)                  //控制闹钟时针加
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           alarm_hour++;
                                                           if(alarm_hour%16 == 0x0a)
                                                           {
                                                                           alarm_hour += 16;
                                                                        alarm_hour &= 0xf0;
                                                           }if(alarm_hour==0x24)alarm_hour=0;
                                                            SectorErase(0x2601);
                                                                byte_write(0x2601,alarm_hour);
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)                          //控制闹钟时针减
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           alarm_hour--;
                                                           if(alarm_hour%16==0x0f && alarm_hour!=0xff)
                                                           {
                                                                        alarm_hour &= 0xf9;
                                                           }
                                                           if(alarm_hour==0xff)alarm_hour=0x23;
                                                           SectorErase(0x2601);
                                                           byte_write(0x2601,alarm_hour);
                                                        }
                                                        while(k4==0);
                                                }
                                                LcdWriteCom(0xc9);
                                                LcdWritestr("  ");
                                break;
                case 2:
                                delay_ms(10);
                                
                                                if(k3==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k3 ==0)         //再次判断按键是否按下
                                                        {
                                                           alarm_min++;
                                                           if(alarm_min%16 == 0x0a)
                                                           {
                                                                           alarm_min += 16;
                                                                        alarm_min &= 0xf0;
                                                           }if(alarm_min==0x60)alarm_min=0;
                                                           SectorErase(0x2201);
                                                           byte_write(0x2201,alarm_min);
                                                        }
                                                        while(k3==0);
                                                }
                                                if(k4==0)
                                                {
                                                        delay(1000);   //消除抖动 一般大约10ms
                                                        if(k4 ==0)         //再次判断按键是否按下
                                                        {
                                                           alarm_min--;
                                                           if(alarm_min%16==0x0f && alarm_min!=0xff)
                                                           {
                                                                        alarm_min &= 0xf9;
                                                           }
                                                           if(alarm_min==0xff)alarm_min=0x59;
                                                           SectorErase(0x2201);
                                                           byte_write(0x2201,alarm_min);
                                                        }
                                                        while(k4==0);
                                                }
                                LcdWriteCom(0xcc);
                                LcdWritestr("  ");
                                break;
        }

}

/************闹钟模式*****************/
void alarmclock(void)
{
    if(alarmswitch==ON && alarm_hour==TIME[2] && alarm_min==TIME[1])  //闹钟
        {                        
                beep=0;
                delay_ms(100);
                beep=1;
                delay_ms(100);  
                beep=0;
                delay_ms(100);
                beep=1;
                LcdWriteCom(0x80);
                LcdWritestr("   time out!    ");
                LcdWriteCom(0xc0);
                LcdWritestr("now time: ");
                LcdWriteData(alarm_hour/16+0x30);
                LcdWriteData(alarm_hour%16+0x30);
                LcdWriteData(':');
                LcdWriteData(alarm_min/16+0x30);
                LcdWriteData(alarm_min%16+0x30);
                LcdWritestr("    ");
                delay_ms(500);
                LcdClean();        
        }
        else mode=DISPLAYDATA;
        if(k4==0)
        {
                delay(1000);   //消除抖动 一般大约10ms
                if(k4 ==0)         //再次判断按键是否按下
                {
                         alarmswitch=OFF;
                }
                while(k4==0);
        }      
}
/*******************************************************************************
* 函 数 名         : main
* 函数功能                   : 主函数
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void main(void)
{
        int ucount=0;
        LcdInit();                         //lcd初始化
        //Ds1302Init();                  //时钟初始化
        Ds18b20Init();                  //温度传感器初始化
        SectorErase(0x2001);
//        byte_write(0x2001,0x08);           //执行一遍初始化
//        byte_write(0x2201,0x00);
//        byte_write(0x2401,0x00);
        alarm_hour=byte_read(0x2601);
        alarm_min=byte_read(0x2201);
        alarmswitch=byte_read(0x2401);

        while(1)               
        {
                switch(mode)        //模式选择
                {
                        case DISPLAYDATA:                //时间显示模式
                                Ds1302ReadTime(); //更新时间
                                display_data();                  //显示时间          秒分时日月周年
                                displaytemp(Ds18b20ReadTemp());//显示温度
                                   keypros();                                 //按键检测
                                if(alarmswitch==ON && alarm_hour==TIME[2] && alarm_min==TIME[1])  //闹钟
                                {
                                        mode = ALARMCLOCK;
                                }
                                break;
                        case MODIFYDATA:                          //时间修改模式
                                modify();
                                break;
                        case SETALARMCLOCK:                           //设置闹钟模式
                                setalarmclock();
                                break;
                        case ALARMCLOCK:                           //闹钟模式
                                alarmclock();
                                break;
                }
               
        }                                
}

就算是用中断，该慢的还是会慢
按你贴的代码来看，主要耗时在LCD1602的显示
1602的显示不用一直刷新，可以在数据有变时再刷或定时(100ms)去刷
而且正常全刷一次都只需2ms
怀疑你的1602驱动代码延时太长

开发板上的程序只是用来学习原理的，实际编程是不用的，实用的按键扫描程序最好是放在定时器中断里，中断的时间是有要求的，必须大于等于10ms，只要大于10ms就不用考虑消抖问题（原理自己百度），延时语句，while(k4==0);都不需要。参考一下我写的按键扫描程序：
http://www.51hei.com/bbs/dpj-208253-1.html

还是中断法按键处理最快，方法很简单，设置外部中断触发方式（上升沿/下降沿等），开总中断，然后在外部中断函数做按键处理。

如果看了我的帖子和回复,采用我的询问式方法就不会有这样问题和提问,也不会想用中断.

按键有三种处理方式：
查询， 中断， 伪中断 。
理论上 中断 最好， 因为响应最及时， 但也是出问题最多的方式。

中断为何出问题多，这里简单说个例子：
低速的MCU ， 例如 STM8L ， 程序不断读取 DS18B20 的温度并显示。
读取18B20时不关中断, 不停按键铁定读出错误；关中断，又影响按键的实时性。

查询法几乎不会出问题，对其他应用没有啥影响。就是反应迟钝。

我现在用的最多的是伪中断。 就是在1ms 的定时器中断中处理 按键， 同时也能完美解决抖动延时。
发现按键后， 置位标志， 然后按需处理。紧急的话立即处理， 不急就在主循环有空处理。很灵活。

实际定时中断里面的代码是这样的：
      if(IT_GetTimer(_KEY_UP)>=KEY_PRESS_DELAY &&  KEY_UP_IN==0) {IT_ClrTimer(_KEY_UP);        IT_SetKey(_KEY_UP, 1);}  // 1=up 2=ok 3=dn
      if(IT_GetTimer(_KEY_OK)>=KEY_PRESS_DELAY &&  KEY_OK_IN==0) {IT_ClrTimer(_KEY_OK);        IT_SetKey(_KEY_OK, 1);}  // 1=up 2=ok 3=dn
      if(IT_GetTimer(_KEY_DN)>=KEY_PRESS_DELAY &&  KEY_DN_IN==0) {IT_ClrTimer(_KEY_DN);        IT_SetKey(_KEY_DN, 1);} // 1=up 2=ok 3=dn       

一家之言， 供大家参考。

一个软件延时都不要用（除非是刚开始的初始化）。

我开始也是用普通延时方式判断按键，的确慢，现实用定时扫描判断按键，灵敏准确迅速，无延时程序

在定时器中断服务程序中, 加入按键扫码代码, 定时器设置为1ms中断. 10或者15次读到按键为低,即为有效, 设置标志位. 然后在主循环中根据标识位执行按键后的动作. 这样按键就非常灵敏,且不会死循环20ms. 20ms单片机可以做很多事情的.

可以用状态机

按键消抖方式太落后，加了延迟，建议抄别人比较成熟的按键扫描方式，定时器扫描之类比较好用