10.5 微控制器長短按鍵的應用

seven-soft發表於2016-07-07
在微控制器系統中應用按鍵的時候，如果只需要按下一次按鍵加 1 或減 1，那用第 8 章學到的知識就可以完成了，但如果想連續加很多數字的時候，要一次次按下這個按鍵確實有點不方便，這時我們會希望一直按住按鍵，數字就自動持續增加或減小，這就是所謂的長短按鍵應用。

當檢測到一個按鍵產生按下動作後，馬上執行一次相應的操作，同時在程式裡記錄按鍵按下的持續時間，該時間超過 1 秒後（主要是為了區別短按和長按這兩個動作，因短按的時間通常都達到幾百 ms），每隔 200ms（如果你需要更快那就用更短的時間，反之亦然）就自動再執行一次該按鍵對應的操作，這就是一個典型的長按鍵效果。

對此，我們做了一個模擬定時炸彈效果的例項，提供給大家作為參考。開啟開關後，數碼管顯示數字 0，按向上的按鍵數字加 1，按向下的按鍵數字減 1，長按向上按鍵 1 秒後，數字會持續增加，長按向下按鍵 1 秒後，數字會持續減小。設定好數字後，按下回車按鍵，時間就會進行倒數計時，當倒數計時到 0 的時候，用蜂鳴器和板子上的 8 個 LED 小燈做炸彈效果，蜂鳴器持續響，LED 小燈全亮。 
  1. #include <reg52.h>
  3. sbit BUZZ = P1^6;
  4. sbit ADDR3 = P1^3;
  5. sbit ENLED = P1^4;
  6. sbit KEY_IN_1 = P2^4;
  7. sbit KEY_IN_2 = P2^5;
  8. sbit KEY_IN_3 = P2^6;
  9. sbit KEY_IN_4 = P2^7;
  10. sbit KEY_OUT_1 = P2^3;
  11. sbit KEY_OUT_2 = P2^2;
  12. sbit KEY_OUT_3 = P2^1;
  13. sbit KEY_OUT_4 = P2^0;
  15. unsigned char code LedChar[] = { //數碼管顯示字元轉換表
  16.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  17.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  18. };
  19. unsigned char LedBuff[7] = { //數碼管+獨立 LED 顯示緩衝區
  20.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
  21. };
  22. unsigned char code KeyCodeMap[4][4] = { //矩陣按鍵編號到標準鍵盤鍵碼的對映表
  23.     { 0x31, 0x32, 0x33, 0x26 }, //數字鍵 1、數字鍵 2、數字鍵 3、向上鍵
  24.     { 0x34, 0x35, 0x36, 0x25 }, //數字鍵 4、數字鍵 5、數字鍵 6、向左鍵
  25.     { 0x37, 0x38, 0x39, 0x28 }, //數字鍵 7、數字鍵 8、數字鍵 9、向下鍵
  26.     { 0x30, 0x1B, 0x0D, 0x27 } //數字鍵 0、ESC 鍵、 Enter鍵、 向右鍵
  27. };
  28. unsigned char KeySta[4][4] = { //全部矩陣按鍵的當前狀態
  29.     {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  30. };
  31. unsigned long pdata KeyDownTime[4][4] = { //每個按鍵按下的持續時間，單位 ms
  32.     {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}
  33. };
  35. bit enBuzz = 0; //蜂鳴器使能標誌
  36. bit flag1s = 0; //1 秒定時標誌
  37. bit flagStart = 0; //倒數計時啟動標誌
  38. unsigned char T0RH = 0; //T0 過載值的高位元組
  39. unsigned char T0RL = 0; //T0 過載值的低位元組
  40. unsigned int CountDown = 0; //倒數計時計數器
  42. void ConfigTimer0(unsigned int ms);
  43. void ShowNumber(unsigned long num);
  44. void KeyDriver();
  46. void main(){
  47.     EA = 1; //使能總中斷
  48.     ENLED = 0; //選擇數碼管和獨立 LED
  49.     ADDR3 = 1;
  50.     ConfigTimer0(1); //配置 T0 定時 1ms
  51.     ShowNumber(0); //上電顯示 0
  52.    
  53.     while (1){
  54.         KeyDriver(); //呼叫按鍵驅動函式
  55.         if (flagStart && flag1s){ //倒數計時啟動且 1 秒定時到達時，處理倒數計時
  56.             flag1s = 0;
  57.             if (CountDown > 0){ //倒數計時未到 0 時，計數器遞減
  58.                 CountDown--;
  59.                 ShowNumber(CountDown); //重新整理倒數計時數顯示
  60.                 if (CountDown == 0){ //減到 0 時，執行聲光報警
  61.                     enBuzz = 1;
  62.                     //啟動蜂鳴器發聲
  63.                     LedBuff[6] = 0x00; //點亮獨立 LED
  64.                 }
  65.             }
  66.         }
  67.     }
  68. }
  69. /* 配置並啟動 T0，ms-T0 定時時間 */
  70. void ConfigTimer0(unsigned int ms){
  71.     unsigned long tmp; //臨時變數
  72.     tmp = 11059200 / 12; //定時器計數頻率
  73.     tmp = (tmp * ms) / 1000; //計算所需的計數值
  74.     tmp = 65536 - tmp; //計算定時器過載值
  75.     tmp = tmp + 28; //補償中斷響應延時造成的誤差
  76.     T0RH = (unsigned char)(tmp>>8); //定時器過載值拆分為高低位元組
  77.     T0RL = (unsigned char)tmp;
  78.     TMOD &= 0xF0; //清零 T0 的控制位
  79.     TMOD |= 0x01; //配置 T0 為模式 1
  80.     TH0 = T0RH; //載入 T0 過載值
  81.     TL0 = T0RL;
  82.     ET0 = 1; //使能 T0 中斷
  83.     TR0 = 1; //啟動 T0
  84. }
  85.     /* 將一個無符號長整型的數字顯示到數碼管上，num-待顯示數字 */
  86. void ShowNumber(unsigned long num){
  87.     signed char i;
  88.     unsigned char buf[6];
  89.     for (i=0; i<6; i++){ //把長整型數轉換為 6 位十進位制的陣列
  90.         buf[i] = num % 10;
  91.         num = num / 10;
  92.     }
  93.     for (i=5; i>=1; i--){ //從最高位起，遇到 0 轉換為空格，遇到非 0 則退出迴圈
  94.         if (buf[i] == 0){
  95.             LedBuff[i] = 0xFF;
  96.         }else{
  97.             break;
  98.         }
  99.     }
  100.    
  101.     for ( ; i>=0; i--){ //剩餘低位都如實轉換為數碼管顯示字元
  102.         LedBuff[i] = LedChar[buf[i]];
  103.     }
  104. }
  105. /* 按鍵動作函式，根據鍵碼執行相應的操作，keycode-按鍵鍵碼 */
  106. void KeyAction(unsigned char keycode){ //按鍵動作函式，根據鍵碼執行相應動作
  107.     if (keycode == 0x26){ //向上鍵，倒數計時設定值遞增
  108.         if (CountDown < 9999){ //最大計時 9999 秒
  109.             CountDown++;
  110.             ShowNumber(CountDown);
  111.         }
  112.     }else if (keycode == 0x28){ //向下鍵，倒數計時設定值遞減
  113.         if (CountDown > 1){ //最小計時 1 秒
  114.             CountDown--;
  115.             ShowNumber(CountDown);
  116.         }
  117.     }else if (keycode == 0x0D){ //Enter鍵，啟動倒數計時
  118.         flagStart = 1; //啟動倒數計時
  119.     }else if (keycode == 0x1B){ //Esc 鍵，取消倒數計時
  120.         enBuzz = 0; //關閉蜂鳴器
  121.         LedBuff[6] = 0xFF; //關閉獨立 LED
  122.         flagStart = 0; //停止倒數計時
  123.         CountDown = 0; //倒數計時數歸零
  124.         ShowNumber(CountDown);
  125.     }
  126. }
  127. /* 按鍵驅動函式，檢測按鍵動作，排程相應動作函式，需在主迴圈中呼叫 */
  128. void KeyDriver(){
  129.     unsigned char i, j;
  130.     static unsigned char pdata backup[4][4] = { //按鍵值備份，儲存前一次的值
  131.         {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  132.     };
  133.     static unsigned long pdata TimeThr[4][4] = { //快速輸入執行的時間閾值
  134.         {1000, 1000, 1000, 1000}, {1000, 1000, 1000, 1000},
  135.         {1000, 1000, 1000, 1000}, {1000, 1000, 1000, 1000}
  136.     };
  137.    
  138.     for (i=0; i<4; i++){ //迴圈掃描 4*4 的矩陣按鍵
  139.         for (j=0; j<4; j++){
  140.             if (backup[i][j] != KeySta[i][j]){ //檢測按鍵動作
  141.                 if (backup[i][j] != 0){ //按鍵按下時執行動作
  142.                     KeyAction(KeyCodeMap[i][j]); //呼叫按鍵動作函式
  143.                 }
  144.             }
  145.             backup[i][j] = KeySta[i][j];
  146.             if (KeyDownTime[i][j] > 0){
  147.                 if (KeyDownTime[i][j] >= TimeThr[i][j]){ //達到閾值時執行一次動作
  148.                     KeyAction(KeyCodeMap[i][j]); //呼叫按鍵動作函式
  149.                     TimeThr[i][j] += 200; //時間閾值增加 200ms，以準備下次執行
  150.                 }
  151.             }else{ //按鍵彈起時復位閾值時間
  152.                 TimeThr[i][j] = 1000; //恢復 1s 的初始閾值時間
  153.             }
  154.         }
  155.     }
  156. }
  157. /* 按鍵掃描函式，需在定時中斷中呼叫 */
  158. void KeyScan(){
  159.     unsigned char i;
  160.     static unsigned char keyout = 0; //矩陣按鍵掃描輸出索引
  161.    
  162.     static unsigned char keybuf[4][4] = { //矩陣按鍵掃描緩衝區
  163.         {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
  164.         {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
  165.     };
  166.    
  167.     //將一行的 4 個按鍵值移入緩衝區
  168.     keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
  169.     keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
  170.     keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
  171.     keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
  172.     //消抖後更新按鍵狀態
  173.     for (i=0; i<4; i++){ //每行 4 個按鍵，所以迴圈 4 次
  174.         //連續 4 次掃描值為 0，即 4*4ms 內都是按下狀態時，可認為按鍵已穩定的按下
  175.         if ((keybuf[keyout][i] & 0x0F) == 0x00){
  176.             KeySta[keyout][i] = 0;
  177.             KeyDownTime[keyout][i] += 4; //按下的持續時間累加
  178.         //連續 4 次掃描值為 1，即 4*4ms 內都是彈起狀態時，可認為按鍵已穩定的彈起
  179.         }else if ((keybuf[keyout][i] & 0x0F) == 0x0F){
  180.             KeySta[keyout][i] = 1;
  181.         }
  182.     }
  183.     KeyDownTime[keyout][i] = 0; //按下的持續時間清零
  184.     //執行下一次的掃描輸出
  185.     keyout++; //輸出索引遞增
  186.     keyout &= 0x03; //索引值加到 4 即歸零
  187.     switch (keyout){ //根據索引，釋放當前輸出引腳，拉低下次的輸出引腳
  188.         case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
  189.         case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
  190.         case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
  191.         case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
  192.         default: break;
  193.     }
  194. }
  195. /* LED 動態掃描重新整理函式，需在定時中斷中呼叫 */
  196. void LedScan(){
  197.     static unsigned char i = 0; //動態掃描索引
  198.     P0 = 0xFF; //關閉所有段選位，顯示消隱
  199.     P1 = (P1 & 0xF8) | i; //位選索引值賦值到 P1 口低 3 位
  200.     P0 = LedBuff[i]; //緩衝區中索引位置的資料送到 P0 口
  201.     if (i < 6){ //索引遞增迴圈，遍歷整個緩衝區
  202.         i++;
  203.     }else{
  204.         i = 0;
  205.     }
  206. }
  207. /* T0 中斷服務函式，完成數碼管、按鍵掃描與秒定時 */
  208. void InterruptTimer0() interrupt 1{
  209.     static unsigned int tmr1s = 0; //1 秒定時器
  210.     TH0 = T0RH; //重新載入過載值
  211.     TL0 = T0RL;
  212.     if (enBuzz){ //蜂鳴器發聲處理
  213.         BUZZ = ~BUZZ; //驅動蜂鳴器發聲
  214.     }else{
  215.         BUZZ = 1; //關閉蜂鳴器
  216.     }
  217.     LedScan(); //LED 掃描顯示
  218.     KeyScan(); //按鍵掃描
  219.     if (flagStart){ //倒數計時啟動時處理 1 秒定時
  220.         tmr1s++;
  221.         if (tmr1s >= 1000){
  222.             tmr1s = 0;
  223.             flag1s = 1;
  224.         }
  225.     }else{ //倒數計時未啟動時 1 秒定時器始終歸零
  226.         tmr1s = 0;
  227.     }
  228. }





長按鍵功能實現的重點有兩個：第一，是在原來的矩陣按鍵掃描函式 KeyScan 內，當檢測到按鍵按下後，持續的對一個時間變數進行累加，其目的是用這個時間變數來記錄按鍵按下的時間；第二，是在按鍵驅動函式 KeyDriver
 裡，除了原來的檢測到按鍵按下這個動作時執行按鍵動作函式 KeyAction 外，還監測表示按鍵按下時間的變數，根據它的值來完成長按時的連續快速按鍵動作功能。
            




相關文章