标题: 求肋STC8A8K64S12单片机矩阵键盘扫描,端口赋值特别慢，造成键盘不能用 [打印本页]
作者: hmgqljz111    时间: 2019-8-29 20:10
标题: 求肋STC8A8K64S12单片机矩阵键盘扫描,端口赋值特别慢，造成键盘不能用
STC8A8K64S12 矩阵键盘P1口接的，端口赋值特别慢，造成键盘不能用。请帮忙一下。谢谢。                  

  1.                  P1=0Xfe;
  2.                   temp1=P1;
  3.                   temp1=temp1&0xf0;
  4.                   if(temp1!=0Xf0)
  5.                     {
  6.                                  delay(2);
  7.                                 
  8.                                 temp1=P1;
  9.                                 temp1=temp1&0xf0;
  10.                                 f(temp1!=0Xf0)
  11.                                         {
  12.                                           temp1=P1;
  13.                                           switch(temp1)
  14.                                                  {
  15.                                                    case 0Xde:  //s1          jt
  16.                                                          {
  17.                                                                   delay(20);
  18.                                                                      kai=0;
  19.                                                                      bi=1;
  20.                                                                   delay(100);
  21.                                                              }
  22.                                                 
  23.                                                          
  24.                                                         break;
  25.                                                           case 0xbe:  
  26.                                                                {
  27.                                                                     ES=0;
  28.                                                                         for(i=0;i<12;i++)
  29.                                                                             {
  30.                                                                                   SBUF=a[i];
  31.                                                                                   while(!TI);
  32.                                                                                   TI=0;
  33.                                                                                 }
  34.                                                                          ES=1;
  35.                                                                          tem_key1=80;
  36.                                                                         }
  37.                                                         break;
  38.                                                           case 0xee:        
  39.                                                                {
  40.                                                                     ES=0;
  41.                                                                         for(i=0;i<12;i++)
  42.                                                                             {
  43.                                                                                   SBUF=b[i];
  44.                                                                                   while(!TI);
  45.                                                                                   TI=0;
  46.                                                                                 }
  47.                                                                          ES=1;
  48.                                                                          tem_key1=80;
  49.                                                                         }
  50.                                                         break;
  51.                              }
  52.                         }
  53.                                        
  54.                                        
  55.                                           while(temp1!=0xf0)
  56.                                                     {
  57.                                                            kai=1;
  58.                                                               bi=0;
  59.                                                            temp1=P1;
  60.                                                            temp1=temp1&0xf0;
  61.                                                          }
  62.                                                           if(tem_key1==80)
  63.                                                      {                                                            
  64.                                                            tem_key1=0;
  65.                                                            ES=0;
  66.                                                            for(i=0;i<6;i++)
  67.                                                                {
  68.                                                                            SBUF=c[i];
  69.                                                                         while(!TI);
  70.                                                                         TI=0;
  71.                                                                }
  72.                                                           ES=1;
  73.                                                          
  74.                                                          }
  75.                                                                                                    
  76.                  }
  77.                   P1=0Xfd;
  78.                   temp1=P1;
  79.                   temp1=temp1&0xf0;
  80.                   if(temp1!=0Xf0)
  81.                     {
  82.                                  delay(2);
  83.                                 
  84.                                 temp=P1;
  85.                                 temp1=temp1&0xf0;
  86.                                 if(temp!=0Xf0)
  87.                                         {
  88.                                           temp1=P1;
  89.                                           switch(temp1)
  90.                                                  {
  91.                                                    case 0Xbd:  
  92.                                                          {
  93.                                                                      if(duty>1)
  94.                                                    {   
  95.                                                       duty--;
  96.                                                     }
  97.                                                  else
  98.                                                     {
  99.                                                       duty=0;
  100.                                                     }
  101.                                                               }
  102.                                                 
  103.                                                          
  104.                                                         break;
  105.                                                           case 0xdd:
  106.                                                                {
  107.                                                                     ES=0;
  108.                                                                         for(i=0;i<12;i++)
  109.                                                                             {
  110.                                                                                   SBUF=fd[i];
  111.                                                                                   while(!TI);
  112.                                                                                   TI=0;
  113.                                                                                 }
  114.                                                                          ES=1;
  115.                                                                          tem_key1=81;
  116.                                                                         }
  117.                                                         break;
  118.                                                           case 0xed:  
  119.                                                                {
  120.                                                                     ES=0;
  121.                                                                         for(i=0;i<12;i++)
  122.                                                                             {
  123.                                                                                   SBUF=e[i];
  124.                                                                                   while(!TI);
  125.                                                                                   TI=0;
  126.                                                                                 }
  127.                                                                          ES=1;
  128.                                                                         
  129.                                                                         }
  130.                                                         break;
  131.                              }
  132.                         }
  133.                                        
  134.                                        
  135.                                           while(temp1!=0xf0)
  136.                                                     {
  137.                                                           TR0=1;
  138.                                                           temp1=P1;
  139.                                                           temp1=temp1&0xf0;
  140.                                                          }
  141.                                                           if(tem_key1==81)
  142.                                                      {                                                            
  143.                                                            tem_key1=0;
  144.                                                            ES=0;
  145.                                                            for(i=0;i<6;i++)
  146.                                                                {
  147.                                                                            SBUF=stop1[i];
  148.                                                                         while(!TI);
  149.                                                                         TI=0;
  150.                                                                }
  151.                                                           ES=1;
  152.                                                          
  153.                                                          }
  154.                                                                                                    
  155.                  }
  156.                    P1=0Xfb;
  157.                   temp1=P1;
  158.                   temp1=temp1&0xf0;
  159.                   if(temp1!=0Xf0)
  160.                     {
  161.                                  delay(2);
  162.                                 
  163.                                 temp1=P1;
  164.                         temp1=temp1&0xf0;
  165.                         if(temp1!=0Xfb)
  166.                                         {
  167.                                           temp1=P1;
  168.                                           switch(temp1)
  169.                                                  {
  170.                                                    case 0Xbb:  //s7
  171.                                                          {
  172.                                                                   if(duty<10)
  173.                           {
  174.                            duty++;
  175.                           }
  176.                           else
  177.                           {
  178.                            duty=10;
  179.                           }
  180.                                                                           }
  181.                                                 
  182.                                                          
  183.                                                         break;
  184.                                                           case 0xdb:  //s8
  185.                                                                {
  186.                                                                     ES=0;
  187.                                                                         for(i=0;i<12;i++)
  188.                                                                             {
  189.                                                                                   SBUF=g[i];
  190.                                                                                   while(!TI);
  191.                                                                                   TI=0;
  192.                                                                                 }
  193.                                                                          ES=1;
  194.                                                                          tem_key1=81;
  195.                                                                         }
  196.                                                         break;
  197.                                                           case 0xeb:  //s9
  198.                                                                {
  199.                                                                    ES=0;
  200.                                               for(i=0;i<12;i++)
  201.                                                     {
  202.                                                         SBUF=h[i];
  203.                                                               while(!TI);
  204.                                                              TI=0;
  205.                                                          }
  206.                                                          ES=1;
  207.                                                                         }
  208.                                                         break;
  209.                              }
  210.                         }
  211.                                        
  212.                                        
  213.                                           while(temp1!=0xf0)
  214.                                                     {
  215.                                                           TR0=1;
  216.                                                           temp1=P1;
  217.                                                           temp1=temp1&0xf0;
  218.                                                          }
  219.                                                           if(tem_key1==81)
  220.                                                      {                                                            
  221.                                                            tem_key=0;
  222.                                                            ES=0;
  223.                                                            for(i=0;i<6;i++)
  224.                                                                {
  225.                                                                            SBUF=stop1[i];
  226.                                                                         while(!TI);
  227.                                                                         TI=0;
  228.                                                                }
  229.                                                           ES=1;
  230.                                                          
  231.                                                          }
  232.                                                                                                    
  233.                  }
  234.                   P1=0Xf7;
  235.                   temp1=P1;
  236.                   temp1=temp1&0xf0;
  237.                   if(temp1!=0Xf0)
  238.                     {
  239.                                  delay(2);
  240.                                 
  241.                                 temp1=P1;
  242.                         temp1=temp1&0xf0;
  243.                         if(temp1!=0Xf0)
  244.                                         {
  245.                                           temp1=P1;
  246.                                           switch(temp1)
  247.                                                  {
  248.                                                    case 0Xb7:  //S12
  249.                                                          {
  250.                                                                   ES=0;
  251.                                               for(i=0;i<6;i++)
  252.                                                     {
  253.                                                         SBUF=j[i];
  254.                                                               while(!TI);
  255.                                                              TI=0;
  256.                                                          }
  257.                                                          ES=1;
  258.                                                                                 
  259.                                                         
  260.                                                                           }
  261.                                                 
  262.                                                          
  263.                                                         break;
  264.                                                           case 0xd7:  //s11
  265.                                                                {
  266.                                                                     ES=0;
  267.                                                                         for(i=0;i<15;i++)
  268.                                                                             {
  269.                                                                                   SBUF=k[i];
  270.                                                                                   while(!TI);
  271.                                                                                   TI=0;
  272.                                                                                 }
  273.                                                                          ES=1;
  274.                                                                         
  275.                                                                         }
  276.                                                         break;
  277.                                                           case 0xe7:  //s10
  278.                                                                {
  279.                                                                     ES=0;
  280.                                                                         for(i=0;i<24;i++)
  281.                                                                             {
  282.                                                                                   SBUF=l[i];
  283.                                                                                   while(!TI);
  284.                                                                                   TI=0;
  285.                                                                                 }
  286.                                                                          ES=1;
  287.                                                                         
  288.                                                                         }
  289.                                                         break;
  290.                              }
  291.                         }
  292.                                        
  293.                                        
  294.                                           while(temp1!=0xf0)
  295.                                                     {
  296.                                                           temp1=P1;
  297.                                                           temp1=temp1&0xf0;
  298.                                                          }
  299.                                                           /*if(tem_key1==80)
  300.                                                      {                                                            
  301.                                                            tem_key=0;
  302.                                                            ES=0;
  303.                                                            for(i=0;i<6;i++)
  304.                                                                {
  305.                                                                            SBUF=stop[i];
  306.                                                                         while(!TI);
  307.                                                                         TI=0;
  308.                                                                }
  309.                                                           ES=1;
  310.                                                          
  311.                                                          } */
  312.                                                                                                    
  313.                  }
复制代码


作者: wulin    时间: 2019-8-30 05:22
不要轻易怀疑MCU问题，STC8端口赋值倒正确读出端口数据的时间小于1us。楼主使用矩阵键盘主要任务是发送串口数据，洋洋洒洒两百多条语句绝大多数是重复的。这样简单的功能只要把此程序分解为3个程序+几个变量和标志即可完成。矩阵按键程序只输出键值、按键服务程序根据键值做出相应响应再调用串口发送程序。
作者: 鹏博士PBs    时间: 2019-8-30 09:09
楼主代码不全啊
作者: hmgqljz111    时间: 2019-8-30 10:55
wulin 发表于 2019-8-30 05:22
不要轻易怀疑MCU问题，STC8端口赋值倒正确读出端口数据的时间小于1us。楼主使用矩阵键盘主要任务是发送串口 ...

哈哈。谢谢指教。我再 试一下。
作者: hmgqljz111    时间: 2019-8-30 10:59
wulin 发表于 2019-8-30 05:22
不要轻易怀疑MCU问题，STC8端口赋值倒正确读出端口数据的时间小于1us。楼主使用矩阵键盘主要任务是发送串口 ...

还想请教一下。代码在89C52上面使用没问题的。我是后来换了MCU才出现的这种情况。换了MCU以后。我只是把以前用定时器产生的PWM，改成了STC8A内置的PWM其他的没有变化。别外P0口接了一个74CH148优先编码器，做的有线键盘功能 都是正常的，只是矩阵键盘不正常。
作者: hmgqljz111    时间: 2019-8-30 11:01
wulin 发表于 2019-8-30 05:22
不要轻易怀疑MCU问题，STC8端口赋值倒正确读出端口数据的时间小于1us。楼主使用矩阵键盘主要任务是发送串口 ...

您的意思是根据返回的键值，和标志，在松手时做出判断执行吗
作者: wulin    时间: 2019-8-30 20:42
hmgqljz111 发表于 2019-8-30 11:01
您的意思是根据返回的键值，和标志，在松手时做出判断执行吗

按键后立即响应，与是否松手无关。给你写一个示例参考。
  1. #include <reg52.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. uchar KeySec;                                        //定义键值全局变量
  5. void keyscan()                                        //4*4矩阵按键扫描程序
  6. {
  7.         static bit sign=0;                        //按键自锁标志
  8.         static uint count=0;                //消抖计数变量                       
  9.         uchar num=0;                                //临时变量
  10.         P3=0xf0;                                        //赋值P3 1111 0000
  11.         if(P3!=0xf0)                                //检测有按键按下
  12.         {
  13.                 if((++count>=100)&&(sign==0))//100~1000，根据主循环周期调整到约10ms
  14.                 {                       
  15.                         sign=1;                                //按键自锁标志置1
  16.                         num=P3;                                //保存P3值xxxx 0000，x为0或1
  17.                         num|=0x0f;                        //保存num按位或0x0f值xxxx 1111
  18.                         P3=num;                                //赋值P3 xxxx 1111
  19.                         num=P3;                                //读取并保存P3值xxxx xxxx
  20.                         switch(num)
  21.                         {
  22.                                 case 0xee: KeySec= 1; break;
  23.                                 case 0xde: KeySec= 2; break;
  24.                                 case 0xbe: KeySec= 3; break;
  25.                                 case 0x7e: KeySec= 4; break;
  26.                                 case 0xed: KeySec= 5; break;
  27.                                 case 0xdd: KeySec= 6; break;
  28.                                 case 0xbd: KeySec= 7; break;
  29.                                 case 0x7d: KeySec= 8; break;
  30.                                 case 0xeb: KeySec= 9; break;
  31.                                 case 0xdb: KeySec=10; break;
  32.                                 case 0xbb: KeySec=11; break;
  33.                                 case 0x7b: KeySec=12; break;
  34.                                 case 0xe7: KeySec=13; break;
  35.                                 case 0xd7: KeySec=14; break;
  36.                                 case 0xb7: KeySec=15; break;
  37.                                 case 0x77: KeySec=16; break;
  38.                         }
  39.                 }
  40.         }
  41.         else                                                //键抬起
  42.         {
  43.                 sign=0;                                        //按键自锁标志清0
  44.                 count=0;                                //消抖计数清0
  45.         }
  46. }
  47. void key_service()                        //按键服务程序
  48. {
  49.         switch(KeySec)                                //按键服务状态切换
  50.         {
  51.                 case 1:                                        //事例1号键触发
  52.                         //任务1
  53.                         KeySec=0;                          //键值清零，避免一直触发
  54.                         break;                        //跳出当前程序

  56.                 case 2:                                        //事例2号键触发
  57.                         //任务2
  58.                         KeySec=0;                         //键值清零，避免一直触发
  59.                         break;                        //跳出当前程序

  61.                 case 3:                                        //事例3号键触发
  62.                         //任务3
  63.                         KeySec=0;                          //键值清零，避免一直触发
  64.                         break;                         //跳出当前程序
  65.                 case 4:                                        //事例4号键触发
  66.                         //任务4
  67.                         KeySec=0;                          //键值清零，避免一直触发
  68.                         break;                        //跳出当前程序

  70.                 case 5:                                        //事例5号键触发
  71.                         //任务5
  72.                         KeySec=0;                         //键值清零，避免一直触发
  73.                         break;                        //跳出当前程序

  75.                 case 6:                                        //事例6号键触发
  76.                         //任务6
  77.                         KeySec=0;                          //键值清零，避免一直触发
  78.                         break;                         //跳出当前程序
  79.                 case 7:                                        //事例7号键触发
  80.                         //任务7
  81.                         KeySec=0;                          //键值清零，避免一直触发
  82.                         break;                        //跳出当前程序
  83.                 case 8:                                        //事例8号键触发
  84.                         //任务8
  85.                         KeySec=0;                         //键值清零，避免一直触发
  86.                         break;                        //跳出当前程序
  87.                 case 9:                                        //事例9号键触发
  88.                         //任务9
  89.                         KeySec=0;                          //键值清零，避免一直触发
  90.                         break;                         //跳出当前程序
  91.                 case 10:                                //事例10号键触发
  92.                         //任务10
  93.                         KeySec=0;                          //键值清零，避免一直触发
  94.                         break;                        //跳出当前程序
  95.                 case 11:                                //事例11号键触发
  96.                         //任务11
  97.                         KeySec=0;                         //键值清零，避免一直触发
  98.                         break;                        //跳出当前程序
  99.                 case 12:                                //事例12号键触发
  100.                         //任务12
  101.                         KeySec=0;                          //键值清零，避免一直触发
  102.                         break;                         //跳出当前程序
  103.                 case 13:                                //事例13号键触发
  104.                         //任务13
  105.                         KeySec=0;                         //键值清零，避免一直触发
  106.                         break;                        //跳出当前程序
  107.                 case 14:                                //事例14号键触发
  108.                         //任务14
  109.                         KeySec=0;                          //键值清零，避免一直触发
  110.                         break;                         //跳出当前程序
  111.                 case 15:                                //事例15号键触发
  112.                         //任务15
  113.                         KeySec=0;                          //键值清零，避免一直触发
  114.                         break;                        //跳出当前程序
  115.                 case 16:                                //事例16号键触发
  116.                         //任务16
  117.                         KeySec=0;                         //键值清零，避免一直触发
  118.                         break;                        //跳出当前程序
  119.         }                  
  120. }
  121. void main()                                                //主函数
  122. {
  123.         while(1)
  124.         {
  125.                 keyscan();                                //按键扫描程序
  126.                 key_service();                        //按键服务程序
  127.         }
  128. }
复制代码

作者: hmgqljz111    时间: 2019-8-31 07:23
wulin 发表于 2019-8-30 20:42
按键后立即响应，与是否松手无关。给你写一个示例参考。

谢谢师傅，我一会试一下。
作者: hmgqljz111    时间: 2019-9-5 22:06
hmgqljz111 发表于 2019-8-31 07:23
谢谢师傅，我一会试一下。

师傅我还想再请教一下，按照您给的那个例子。我也试了效果不错，就是有些按键按完后。松手的时候要往串口发送数据 。我没弄明白，这种方式 如何判断按键松手。
作者: wulin    时间: 2019-9-6 06:37
按键自锁标志sign就是判断按键按下和松手的依据，如果其它程序也要用sign这个标志要把其改为全局变量。
作者: hmgqljz111    时间: 2019-9-6 08:45
wulin 发表于 2019-9-6 06:37
按键自锁标志sign就是判断按键按下和松手的依据，如果其它程序也要用sign这个标志要把其改为全局变量。

好的，我试试，谢谢老师



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1