k1控制开、关，k2按下加一，k3按下减一，

k2加一，k3减一之前试过了，可以，但是要k1开的时候，k2、k3才能加一减一，这个没有做到，k1没开的时候，k2也会从零开始加一；现在我改了程序，出现别的问题（但是我懂得改回原先的样子），请问怎样才能k1开的时候k2加一、减一呢?

1. #include<at89x52.h>
   
2. #define uchar unsigned char
   
3. sbit k1=P3^0;
   
4. sbit k2=P3^2;
   
5. sbit k3=P3^4;
   
6. uchar code tab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
   
7. 
   
8. void delay1ms(uchar a)  
   
9. {
   
10.      uchar b,c;
    
11.     for(c=1;c>0;c--)
    
12.         for(b=142;b>0;b--)
    
13.             for(a=2;a>0;a--);
    
14. }
    
15. 
    
16. void main()
    
17. {
    
18.   uchar i;
    
19.   while(1)
    
20.   {
    
21. 
    
22.    if(k1==0)
    
23.    {
    
24.     delay1ms(10);
    
25.     if(k1==0)
    
26.     {
    
27.       P2=0xc0;
    
28.     }
    
29.     while(！k1);
    
30.    }
    
31. 
    
32.    if(P2==0xc0)
    
33.    {
    
34.       if(k2==0)
    
35.       {
    
36.         delay1ms(10);
    
37.         if(k2==0)
    
38.        {
    
39.          P2=tab[++i];  
    
40.        }
    
41.          while(！k2);
    
42.       }
    
43.    }
    
44. 
    
45.       if(k3==0)
    
46.       {
    
47.        delay1ms(10);
    
48.        if(k3==0)
    
49.        {
    
50.          P2=tab[--i];
    
51.        }
    
52.          while(！k3);
    
53.       }
    
54.   }
    
55. }

复制代码

//需要声明的变量
bit Switch=1;                                                //开关机标志位
unsigned char num=0;                                //需要+-控制的变量
//此按键程序适合放在主程序中运行
void key_scan()       
{
        static bit key1_sign=0,key2_sign=0,key3_sign=0;        //按键自锁标志
        static unsigned char count1=0,count2=0,count3=0;//消抖计数变量                       
        if(key1==0)                                                //检测按键1如果按下为0
        {
                count1++;                                        //消抖计数
                if(count1>=200)                                //消抖延时
                {
                        count1=200;                                //防止溢出
                        if(key1_sign==0)                //按键自锁志为0
                        {
                                key1_sign=1;                //按键自锁志置1
                                Switch=~Switch;                //开关机标志位取反
                                if(Switch==0)                //如果开关机标志位为0
                                {
                                        //需要控制的内容
                                }
                                else
                                {
                                        //需要控制的内容
                                }       
                        }
                }
        }       
        else
        {
                key1_sign=0;                                //按键自锁标志清0
                count1=0;                                        //消抖计数清0
        }
        if(！key2&(！key2^Switch))                //检测按键2如果按下为0，开关机标志位为0
        {
                count2++;                                        //消抖计数
                if(count2>=200)                                //消抖延时
                {
                        count2=200;                                //防止溢出
                        if(key2_sign==0)                //按键自锁标志为0
                        {
                                key2_sign=1;                //按键自锁标志置1       
                                if(num<8)                        //设置上限
                                        num++;
                                //其他需要控制的内容
                        }
                }
        }
        else
        {
                key2_sign=0;                                //按键自锁标志清0
                count2=0;                                        //消抖计数清0
        }
        if(！key3&(！key3^Switch))                //检测按键3如果按下为0，开关机标志位为0
        {
                count3++;                                        //消抖计数
                if(count3>=200)                                //消抖延时
                {
                        count3=200;                                //防止溢出
                        if(key3_sign==0)                //按键自锁标志为0
                        {
                                key3_sign=1;                //按键自锁标志置1
                                if(num>0)                        //设置下限
                                        num--;
                                //其他需要控制的内容
                        }
                }
        }       
        else
        {
                key3_sign=0;                                //按键自锁标志清0
                count3=0;                                        //消抖计数清0
        }
}

应该设一个变量来存储K1按下的状态，即开，关两个状态，也就是当这个变量代表关的时候，如果按下K1，就把这个变量改为代表开，再按下K1，则把这个变量改为代表关。
只有当这个变量为开的状态时，才去扫描K2，K3键。

哈，可以了，谢谢你