设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机不同按键控制不同IO口输出驱动三极管遇到难题
返回列表 发新帖
查看: 1654|回复: 7
打印 上一主题 下一主题
收起左侧

单片机不同按键控制不同IO口输出驱动三极管遇到难题

[复制链接]
跳转到指定楼层
楼主
ID:799716 发表于 2020-7-24 10:22 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
4个按键  K1 K2 K3 K4 ,其中 K1是开启和暂停键（本来想长按开显示短按启动定时器 新手还没这么去编程），K2 K3 K4 按键每个按键下可以选择工作时长：按一下能切 5分钟 10分钟 15分钟  K2对应一个IO口驱动三极管 K3K4都是一样的（工作时长略微不同而已）。 现在遇到的问题点是， 1.K2选好时间档位，我按下K1开关/暂停 键，正常运行倒计时，时间没到00能正常启动/暂停，到00了选其他时间档位就不能正常启动了倒计时。。。2.K2控制的输出IO口置高，然后其他2个输出口为0,但是实际编出来的效果是暂停了 K2控制的IO口还是输出高。。。不同按键单独控制一个IO口 暂停时关闭，启动是打开，思路是有，但是C语音编程就是没效果。。。一直查资料2天了没进展，附上 按键和定时器的编码

单片机源程序如下:
void Key_Event_Handle()  
{
                if((K1==0)&&(munite_counts!=0))     
                                                {
                                                        DelayMS(10);
                                                        if(K1==0)
                                                        {
                                                                while(!K1);
                                                                ET0=~ET0;
                                                                TR0=~TR0;
                                                        /*        if((flag==1)&&(TR0==1))
                                                                {
                                                                        flag=0;
                                                                        SONIC=1;
                                                                        HEAT=0;
                                                                        UV=0;
                                                                }
                                                                if((flag1==1)&&(TR0==1))
                                                                {
                                                                        flag1=0;
                                                                        SONIC=0;
                                                                        HEAT=1;
                                                                        UV=0;
                                                                }        
                                                                if((flag2==1)&&(TR0==1))
                                                                {
                                                                        flag2=0;
                                                                        SONIC=0;
                                                                        HEAT=0;
                                                                        UV=1;
                                                                }        */        
                                                        }        
                                                }
               
                if(K2==0)
                {
                        DelayMS(10);
                                if(K2==0)
                                {
                                 flag=1;
                                        flag1=0;
                                        flag2=0;
                                                K2num++;           
                                                while(!K2);  
                                                K3num=0;
                                                K4num=0;
                                //                ET0=0;
                                        //        TR0=0;

                                                if(K2num==1)
                                                {
                                                        munite_counts=3;
                                                        Second_Counts=0;
                                                }
                                                if(K2num==2)                         //
                                                {
                                                        munite_counts=10;
                                                }
                                                if(K2num==3)                 //
                                                {
                                                        munite_counts=15;
                                                }
                                                if(K2num==4)                 //
                                                {
                                                        munite_counts=20;
                                                }
                                                if(K2num==5)                         //
                                                {
                                                        K2num=0;
                                                        munite_counts=2;
                                                }
                                        }
                                Key_Flag_Idx=0;
                                        i=0;
                        }        
               
                if(K3==0)
                {
                        DelayMS(10);  
                                if(K3==0)
                                {
                                        flag=0;
                                        flag1=1;
                                        flag2=0;
                                                K3num++;         
                                                while(!K3);
                                                K2num=0;
                                                K4num=0;
                                                //ET0=0;
                                                //TR0=0;

                                                if(K3num==1)  
                                                {
                                                        munite_counts=2;
                                                        Second_Counts=0;
                                                }
                                                if(K3num==2)                         //
                                                {
                                                        munite_counts=10;
                                                }
                                                if(K3num==3)                 //
                                                {
                                                        munite_counts=20;
                                                }
                                                if(K3num==4)                         //
                                                {
                                                        munite_counts=30;
                                                }
                                                if(K3num==5)                         //
                                                {
                                                        K3num=0;
                                                        munite_counts=3;
                                                }
                                }
                                Key_Flag_Idx=0;
                                i=0;
                        }
                                
                if(K4==0)
                        {
                        DelayMS(10);
                                if(K4==0)
                                {
                                        flag=0;
                                        flag1=0;
                                        flag2=1;
                                while(!K4);
                                                K2num=0;
                                                K3num=0;
                                //ET0=0;
                                //TR0=0;
                                munite_counts=1;
                                        Second_Counts=0;
                                }
                                Key_Flag_Idx=0;
                                i=0;
                        }
}


void DSY_Refresh() interrupt 1
{
        TH0=(65536-5000)/256;
        TL0=(65536-5000)%256;
        i++;
        if(i==2)  
        {
                i=0;
                Second_Counts++;                        
                if(Second_Counts==60)
                {
                        Second_Counts=0;
                        munite_counts--;
                        if(munite_counts==0)
                        {
                                TR0=0;
                        }
                }
        }
}

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

使用道具 举报

沙发
ID:10947 发表于 2020-7-24 14:39 | 只看该作者
感觉1个定时器就可以了吧
回复

使用道具 举报

板凳
ID:451718 发表于 2020-7-24 15:34 | 只看该作者
TR0=0; 这个操作最好少用，定时器一旦启用，就让它运行下去。 你这样随手关掉， 下次再启用的时候，你能保证初值没有溢出么？     而且，你这个是在定时器中断里面 做这样的操作。  定时器都不动了，外面的程序如何判断计时。
回复

使用道具 举报

地板
ID:799716 发表于 2020-7-24 16:08 | 只看该作者
现在不会如何检验K2按下打开超声，K3按下打开加热，K4按下 打开智能模式。。一个按键只打开一个功能
回复

使用道具 举报

5#
ID:799716 发表于 2020-7-24 16:11 | 只看该作者
lfc315 发表于 2020-7-24 14:39
感觉1个定时器就可以了吧

我如何设计 K2按下打开加热功能，K3按下打开另外一种功能（加热功能关闭），K4按下再打开另外一种功能（其他功能关闭）。有思路，就是哪个键按下 就写个标记位置1，但是切到别的按键思路就不清晰了
回复

使用道具 举报

6#
ID:213173 发表于 2020-7-24 22:19 | 只看该作者
k1启动/暂停，k2~k4  3路独立倒计时，数码管16进制显示 t  x  x  x，P1.0~P1.2低电平输出，全部到0恢复初始状态。
  1. #include  <reg51.h>
  2. #define  uchar  unsigned  char
  3. #define  uint unsigned int
  4. #define duan P0

  6. sbit k1=P2^4;
  7. sbit k2=P2^5;
  8. sbit k3=P2^6;
  9. sbit k4=P2^7;
  10. sbit OUT1=P1^0;
  11. sbit OUT2=P1^1;
  12. sbit OUT3=P1^2;

  14. uchar code table[]={//共阳数码管段码"0~f-."
  15.                 0xc0,0xf9,0xa4,0xb0,
  16.                 0x99,0x92,0x82,0xf8,
  17.                 0x80,0x90,0x88,0x83,
  18.                 0xc6,0xa1,0x86,0x8e,0xbf,0x7f};
  19. uchar data dis_buf[4];
  20. uchar a,b,c,d;
  21. uint count;
  22. bit sign;
  23. bit flag;
  24. uint num=0,num1=0,num2=0,num3=0;


  27. void delay(uint t)
  28. {        
  29.         uint i,j;
  30.         for(i=t;i>0;i--)
  31.                 for(j=112;j>0;j--);
  32. }
  33. void InitTimer0(void)
  34. {
  35.     TMOD = 0x01;
  36.     TH0 = 0x3C;
  37.     TL0 = 0xB0;
  38.     EA = 1;
  39.     ET0 = 1;
  40.     TR0 = 1;
  41. }
  42. void display()
  43. {
  44.         if(flag)
  45.                 dis_buf[0]=0x87;
  46.         else
  47.                 dis_buf[0]=0xbf;
  48.         dis_buf[1]=table[b];
  49.         dis_buf[2]=table[c];
  50.         dis_buf[3]=table[d];

  52.         P2&=0xf0;//位清0
  53.         P2|=0x01<<num;
  54.         duan=dis_buf[num];//送段码
  55.         num++;
  56.         num%=4;
  57. }

  59. void main()
  60. {
  61.     InitTimer0();
  62.         while(1)
  63.         {
  64.                 if(!k1 || !k2 || !k3 || !k4)
  65.                 {
  66.                         count++;//消抖计数
  67.                         if(count>=10 && sign==0)
  68.                         {
  69.                                 sign=1;//锁定键态
  70.                                 if(!k1){flag=~flag;}
  71.                                 if(!k2){b=b+5;if(b>15)b=0;}
  72.                                 if(!k3){c=c+5;if(c>15)c=0;}
  73.                                 if(!k4){d=d+5;if(d>15)d=0;}
  74.                         }
  75.                 }         
  76.                 else{count=0;sign=0;}
  77.                 if(b!=0)OUT1=0;else OUT1=1;
  78.                 if(c!=0)OUT2=0;else OUT2=1;
  79.                 if(d!=0)OUT3=0;else OUT3=1;
  80.                 display();
  81.                 delay(1);//控制主循环周期约1ms
  82.         }
  83. }
  84. void Timer0Interrupt(void) interrupt 1
  85. {
  86.     TH0 = 0x3C;
  87.     TL0 = 0xB0;
  88.         if(flag)
  89.         {
  90.                 if(b!=0)
  91.                 {
  92.                         num1++;       
  93.                         if(num1>=1200)
  94.                         {
  95.                                 num1=0;
  96.                                 b--;
  97.                         }
  98.                 }
  99.                 if(c!=0)
  100.                 {
  101.                         num2++;       
  102.                         if(num2>=1200)
  103.                         {
  104.                                 num2=0;
  105.                                 c--;
  106.                         }
  107.                 }
  108.                 if(d!=0)
  109.                 {
  110.                         num3++;       
  111.                         if(num3>=1200)
  112.                         {
  113.                                 num3=0;
  114.                                 d--;
  115.                         }
  116.                 }
  117.                 if(b==0&&c==0&&d==0)
  118.                         flag=0;
  119.         }
  120. }
复制代码







回复

使用道具 举报

7#
ID:799716 发表于 2020-7-25 08:28 | 只看该作者
wulin 发表于 2020-7-24 22:19
k1启动/暂停，k2~k4  3路独立倒计时，数码管16进制显示 t  x  x  x，P1.0~P1.2低电平输出，全部到0恢复初始 ...

感谢指导，昨天晚上我也想了，用一个标记来判断哪个键按下，看到你的 ： 按键状态锁定 这个说明后 明朗了 我再继续学习
回复

使用道具 举报

8#
ID:799716 发表于 2020-7-25 15:40 | 只看该作者
void Key_Event_Handle(void)                                                 /按键处理函数
{
        if(!K1||!K2||!K3||!K4)                                                                                        
        {
                count++;                                                                //消抖
                if(count>=10&&sign==0)
                {
                        sign=1;                                                                //按键状态锁定
                        if(!K1){flag=~flag;}
                        if(!K2)
                        {
                                K2NUM++;
                                K3NUM=0;
                                K4NUM=0;
                                if(K2NUM>4)K2NUM=1;
                                switch(K2NUM)
                                {
                                case 1:
                                        time_counts=60;                        //60s工作时间               
                                break;
                               
                                case 2:
                                        time_counts=120;
                                break;
                               
                                case 3:
                                        time_counts=180;
                                break;
                               
                                case 4:
                                        time_counts=660;
                                break;
                                }                                                       
                        }
                if(!K3)
                        {
                                K3NUM++;
                                K2NUM=0;
                                K4NUM=0;
                                if(K3NUM>4)K3NUM=1;
                                switch(K3NUM)
                                        {
                                        case 1:
                                                time_counts=120;                                               
                                        break;
                                       
                                        case 2:
                                                time_counts=180;
                                        break;
                                       
                                        case 3:
                                                time_counts=240;
                                        break;
                                       
                                        case 4:
                                                time_counts=1320;
                                        break;
                                        }
                        }
               
                if(!K4)
                        {
                                K4NUM++;
                                K2NUM=0;
                                K3NUM=0;
                                time_counts=900;                                                                                               
                        }
                }
        }
                else{count=0;sign=0;}
                if((K2NUM!=0)&&(flag==1)||(K4NUM!=0)&&(flag==1)&&(time_counts<=840))SONIC=1;else SONIC=0;
                if((K3NUM!=0)&&(flag==1)||(K4NUM!=0)&&(flag==1)&&(time_counts<=840))UV=1;else UV=0;
                if((K4NUM!=0)&&(flag==1)&&(time_counts>=840))HEAT=1;else HEAT=0;
}
今天调试出来了，K2 K3 K4能选不同档位工作时间，IO孔输出控制也正常了，我是检测到按键按下 就让K2NUM K3NUM K4NUM计数，谁的计数不为零就判断哪个按键按下。。。。(不知道对不对)
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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