欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標(biāo)題: 求肋STC8A8K64S12單片機(jī)矩陣鍵盤掃描,端口賦值特別慢，造成鍵盤不能用 [打印本頁]
作者: hmgqljz111    時(shí)間: 2019-8-29 20:10
標(biāo)題: 求肋STC8A8K64S12單片機(jī)矩陣鍵盤掃描,端口賦值特別慢，造成鍵盤不能用
STC8A8K64S12 矩陣鍵盤P1口接的，端口賦值特別慢，造成鍵盤不能用。請(qǐng)幫忙一下。謝謝。                  

  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.                  }
復(fù)制代碼


作者: wulin    時(shí)間: 2019-8-30 05:22
不要輕易懷疑MCU問題，STC8端口賦值倒正確讀出端口數(shù)據(jù)的時(shí)間小于1us。樓主使用矩陣鍵盤主要任務(wù)是發(fā)送串口數(shù)據(jù)，洋洋灑灑兩百多條語句絕大多數(shù)是重復(fù)的。這樣簡單的功能只要把此程序分解為3個(gè)程序+幾個(gè)變量和標(biāo)志即可完成。矩陣按鍵程序只輸出鍵值、按鍵服務(wù)程序根據(jù)鍵值做出相應(yīng)響應(yīng)再調(diào)用串口發(fā)送程序。
作者: 鵬博士PBs    時(shí)間: 2019-8-30 09:09
樓主代碼不全啊
作者: hmgqljz111    時(shí)間: 2019-8-30 10:55
wulin 發(fā)表于 2019-8-30 05:22
不要輕易懷疑MCU問題，STC8端口賦值倒正確讀出端口數(shù)據(jù)的時(shí)間小于1us。樓主使用矩陣鍵盤主要任務(wù)是發(fā)送串口 ...

哈哈。謝謝指教。我再 試一下。
作者: hmgqljz111    時(shí)間: 2019-8-30 10:59
wulin 發(fā)表于 2019-8-30 05:22
不要輕易懷疑MCU問題，STC8端口賦值倒正確讀出端口數(shù)據(jù)的時(shí)間小于1us。樓主使用矩陣鍵盤主要任務(wù)是發(fā)送串口 ...

還想請(qǐng)教一下。代碼在89C52上面使用沒問題的。我是后來換了MCU才出現(xiàn)的這種情況。換了MCU以后。我只是把以前用定時(shí)器產(chǎn)生的PWM，改成了STC8A內(nèi)置的PWM其他的沒有變化。別外P0口接了一個(gè)74CH148優(yōu)先編碼器，做的有線鍵盤功能 都是正常的，只是矩陣鍵盤不正常。
作者: hmgqljz111    時(shí)間: 2019-8-30 11:01
wulin 發(fā)表于 2019-8-30 05:22
不要輕易懷疑MCU問題，STC8端口賦值倒正確讀出端口數(shù)據(jù)的時(shí)間小于1us。樓主使用矩陣鍵盤主要任務(wù)是發(fā)送串口 ...

您的意思是根據(jù)返回的鍵值，和標(biāo)志，在松手時(shí)做出判斷執(zhí)行嗎
作者: wulin    時(shí)間: 2019-8-30 20:42
hmgqljz111 發(fā)表于 2019-8-30 11:01
您的意思是根據(jù)返回的鍵值，和標(biāo)志，在松手時(shí)做出判斷執(zhí)行嗎

按鍵后立即響應(yīng)，與是否松手無關(guān)。給你寫一個(gè)示例參考。
  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;                        //按鍵自鎖標(biāo)志
  8.         static uint count=0;                //消抖計(jì)數(shù)變量                       
  9.         uchar num=0;                                //臨時(shí)變量
  10.         P3=0xf0;                                        //賦值P3 1111 0000
  11.         if(P3!=0xf0)                                //檢測(cè)有按鍵按下
  12.         {
  13.                 if((++count>=100)&&(sign==0))//100~1000，根據(jù)主循環(huán)周期調(diào)整到約10ms
  14.                 {                       
  15.                         sign=1;                                //按鍵自鎖標(biāo)志置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;                                        //按鍵自鎖標(biāo)志清0
  44.                 count=0;                                //消抖計(jì)數(shù)清0
  45.         }
  46. }
  47. void key_service()                        //按鍵服務(wù)程序
  48. {
  49.         switch(KeySec)                                //按鍵服務(wù)狀態(tài)切換
  50.         {
  51.                 case 1:                                        //事例1號(hào)鍵觸發(fā)
  52.                         //任務(wù)1
  53.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  54.                         break;                        //跳出當(dāng)前程序

  56.                 case 2:                                        //事例2號(hào)鍵觸發(fā)
  57.                         //任務(wù)2
  58.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  59.                         break;                        //跳出當(dāng)前程序

  61.                 case 3:                                        //事例3號(hào)鍵觸發(fā)
  62.                         //任務(wù)3
  63.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  64.                         break;                         //跳出當(dāng)前程序
  65.                 case 4:                                        //事例4號(hào)鍵觸發(fā)
  66.                         //任務(wù)4
  67.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  68.                         break;                        //跳出當(dāng)前程序

  70.                 case 5:                                        //事例5號(hào)鍵觸發(fā)
  71.                         //任務(wù)5
  72.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  73.                         break;                        //跳出當(dāng)前程序

  75.                 case 6:                                        //事例6號(hào)鍵觸發(fā)
  76.                         //任務(wù)6
  77.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  78.                         break;                         //跳出當(dāng)前程序
  79.                 case 7:                                        //事例7號(hào)鍵觸發(fā)
  80.                         //任務(wù)7
  81.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  82.                         break;                        //跳出當(dāng)前程序
  83.                 case 8:                                        //事例8號(hào)鍵觸發(fā)
  84.                         //任務(wù)8
  85.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  86.                         break;                        //跳出當(dāng)前程序
  87.                 case 9:                                        //事例9號(hào)鍵觸發(fā)
  88.                         //任務(wù)9
  89.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  90.                         break;                         //跳出當(dāng)前程序
  91.                 case 10:                                //事例10號(hào)鍵觸發(fā)
  92.                         //任務(wù)10
  93.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  94.                         break;                        //跳出當(dāng)前程序
  95.                 case 11:                                //事例11號(hào)鍵觸發(fā)
  96.                         //任務(wù)11
  97.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  98.                         break;                        //跳出當(dāng)前程序
  99.                 case 12:                                //事例12號(hào)鍵觸發(fā)
  100.                         //任務(wù)12
  101.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  102.                         break;                         //跳出當(dāng)前程序
  103.                 case 13:                                //事例13號(hào)鍵觸發(fā)
  104.                         //任務(wù)13
  105.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  106.                         break;                        //跳出當(dāng)前程序
  107.                 case 14:                                //事例14號(hào)鍵觸發(fā)
  108.                         //任務(wù)14
  109.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  110.                         break;                         //跳出當(dāng)前程序
  111.                 case 15:                                //事例15號(hào)鍵觸發(fā)
  112.                         //任務(wù)15
  113.                         KeySec=0;                          //鍵值清零，避免一直觸發(fā)
  114.                         break;                        //跳出當(dāng)前程序
  115.                 case 16:                                //事例16號(hào)鍵觸發(fā)
  116.                         //任務(wù)16
  117.                         KeySec=0;                         //鍵值清零，避免一直觸發(fā)
  118.                         break;                        //跳出當(dāng)前程序
  119.         }                  
  120. }
  121. void main()                                                //主函數(shù)
  122. {
  123.         while(1)
  124.         {
  125.                 keyscan();                                //按鍵掃描程序
  126.                 key_service();                        //按鍵服務(wù)程序
  127.         }
  128. }
復(fù)制代碼

作者: hmgqljz111    時(shí)間: 2019-8-31 07:23
wulin 發(fā)表于 2019-8-30 20:42
按鍵后立即響應(yīng)，與是否松手無關(guān)。給你寫一個(gè)示例參考。

謝謝師傅，我一會(huì)試一下。
作者: hmgqljz111    時(shí)間: 2019-9-5 22:06
hmgqljz111 發(fā)表于 2019-8-31 07:23
謝謝師傅，我一會(huì)試一下。

師傅我還想再請(qǐng)教一下，按照您給的那個(gè)例子。我也試了效果不錯(cuò)，就是有些按鍵按完后。松手的時(shí)候要往串口發(fā)送數(shù)據(jù) 。我沒弄明白，這種方式 如何判斷按鍵松手。
作者: wulin    時(shí)間: 2019-9-6 06:37
按鍵自鎖標(biāo)志sign就是判斷按鍵按下和松手的依據(jù)，如果其它程序也要用sign這個(gè)標(biāo)志要把其改為全局變量。
作者: hmgqljz111    時(shí)間: 2019-9-6 08:45
wulin 發(fā)表于 2019-9-6 06:37
按鍵自鎖標(biāo)志sign就是判斷按鍵按下和松手的依據(jù)，如果其它程序也要用sign這個(gè)標(biāo)志要把其改為全局變量。

好的，我試試，謝謝老師



歡迎光臨 (http://m.raoushi.com/bbs/) Powered by Discuz! X3.1