久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

<optgroup id="mg0oc"></optgroup>

<strong id="mg0oc"></strong>

<option id="mg0oc"><pre id="mg0oc"></pre></option>

<center id="mg0oc"><tr id="mg0oc"></tr></center>

<noscript id="mg0oc"></noscript>

<option id="mg0oc"><noframes id="mg0oc">

標題: 求肋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;                        //跳出當前程序
    
55. 
    
56.                 case 2:                                        //事例2號鍵觸發
    
57.                         //任務2
    
58.                         KeySec=0;                         //鍵值清零，避免一直觸發
    
59.                         break;                        //跳出當前程序
    
60. 
    
61.                 case 3:                                        //事例3號鍵觸發
    
62.                         //任務3
    
63.                         KeySec=0;                          //鍵值清零，避免一直觸發
    
64.                         break;                         //跳出當前程序
    
65.                 case 4:                                        //事例4號鍵觸發
    
66.                         //任務4
    
67.                         KeySec=0;                          //鍵值清零，避免一直觸發
    
68.                         break;                        //跳出當前程序
    
69. 
    
70.                 case 5:                                        //事例5號鍵觸發
    
71.                         //任務5
    
72.                         KeySec=0;                         //鍵值清零，避免一直觸發
    
73.                         break;                        //跳出當前程序
    
74. 
    
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.zg4o1577.cn/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

久久久久久久999|99精品久久精品一区二区爱城|成人欧美一区二区三区在线播放|国产精品日本一区二区不卡视频|国产午夜视频|欧美精品在线观看免费

主站蜘蛛池模板： 男女深夜网站 | 日韩专区中文字幕 | 做a视频在线观看 | 91免费小视频 | 精品国产一区二区三区免费 | 午夜国产一区 | 日韩一区精品 | 激情久久av一区av二区av三区 | 综合九九 | 久久综合久 | 成人精品鲁一区一区二区 | 美女视频一区二区三区 | 欧美日韩黄色一级片 | 日韩成人高清在线 | 我要看黄色录像一级片 | 成人影视网 | 颜色网站在线观看 | 国产精品爱久久久久久久 | 羞羞网站在线观看 | 欧美一区二区三区 | 久久久国产一区 | 中国大陆高清aⅴ毛片 | 中文字幕av一区 | 日韩毛片在线观看 | 国产高清视频在线观看播放 | 中文字幕综合 | 久久欧美高清二区三区 | 午夜精品久久久久久久久久久久久 | 别c我啊嗯国产av一毛片 | 尤物视频在线免费观看 | 一区二区三区亚洲 | 中文字幕av高清 | 国产高清免费视频 | 一区二区精品视频 | 伊人伊人| 91精品国产一二三 | 精品国产一区二区在线 | 毛片网络| 国产精品a久久久久 | 亚洲精品高清视频 | 9191成人精品久久 |

<code id="ui2e8"></code>

<ul id="ui2e8"><optgroup id="ui2e8"></optgroup></ul>

<pre id="ui2e8"></pre>

<code id="ui2e8"><object id="ui2e8"></object></code>

<noscript id="ui2e8"></noscript>