標題: 51單片機8個IO口掃描檢測64個按鍵+仿真程序+算法實現(xiàn)和心法要點講解 [打印本頁]
作者: perseverance51    時間: 2021-9-11 23:23
標題: 51單片機8個IO口掃描檢測64個按鍵+仿真程序+算法實現(xiàn)和心法要點講解
51單片機8個IO口掃描檢測64個按鍵+數(shù)碼管顯示+程序+Proteus仿真+算法實現(xiàn)和心法要點講解

總結要領     最難的地方是，控制56-64最后一排的數(shù)碼管顯示，因為，這個你是對P0總線端口自身的掃描，最容易出問題的地方，也是卡在這個地方最長時間。一定要了解其單片機運行和按鍵掃描原理。在沒有延時或打斷的情況下，按鍵動作的時間一定是快不過單片機運行的速度。所以在處理最后一排按鍵時，需要特別注意，顯示時要比其他行掃描處理的時間留長一點，不然就很容易跳數(shù)，按下的按鍵，和顯示的數(shù)值不是你想要的結果，下面我會將經(jīng)驗一一寫下來。
仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）

0-64個按鍵，需要考慮消抖的只有最后一排56-64的8個按鍵的響應。為什么這么說呢?這是因為按鍵從設計原理和實現(xiàn)來看的。0-56的按鍵不管你怎么長按還是短按，單片機給你的響應數(shù)值都是一樣的不會變，但是在處理56-64這8個按鍵時，是做了特殊處理，連接的是GND，如果敲代碼沒注意的話，就很容易造成跳數(shù)字，單片機掃描是通過按照規(guī)定先給指定的IO口拉點，再去檢測其他7個IO的電平狀態(tài)，所以在處理第56-64按鍵時，如果你操作的按鍵按下時，單片機掃描按鍵的速度已經(jīng)從你按下那一到彈起前已經(jīng)超過了你的速度，那么會造成，單片機讀取到錯誤的響應數(shù)據(jù)，處理方式如下：
  1. /****************自身端口讀取*********************/
  2.                 P0=0xff;//掃描第8行
  3. //    delay(5);
  4.                 tmp=P0;
  5.     if (Search(arr, 8, tmp))
  6.     {
  7.         //將檢測到的P0狀態(tài)值賦值給臨時變量
  8.         switch(Search(arr, 8, tmp))
  9.         {   //臨時變量對逐個IO口進行查詢
  10.         case 0xfe:
  11.             keynum=57;
  12.             break;//第1行第1個按鍵按下
  13.         case 0xfd:
  14.             keynum=58;
  15.             break;//第1行第2個按鍵按下
  16.         case 0xfb:
  17.             keynum=59;
  18.             break;//第1行第3個按鍵按下
  19.         case 0xf7:
  20.             keynum=60;
  21.             break;//第1行第4個按鍵按下
  22.         case 0xef:
  23.             keynum=61;
  24.             break;//第1行第5個按鍵按下
  25.         case 0xdf:
  26.             keynum=62;
  27.             break;//第1行第6個按鍵按下
  28.         case 0xbf:
  29.             keynum=63;
  30.             break;//第1行第7個按鍵按下
  31.         case 0x7f:
  32.             keynum=64;
  33.             break;//第1行第8個按鍵按下
  34.         }        
  35.                         display();//這里必須單獨處理P0的IO檢測和顯示，否則容易跳數(shù)
  36.                         delay(80);//阻塞按鍵掃描，防止數(shù)碼管跳變，其他行掃描不需要此處的延時。
  37.     }
復制代碼
完整實現(xiàn)代碼：
  1. #include <reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. //共陰極數(shù)碼管0~9
  6. uchar code table[]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//0-9共陰數(shù)碼管
  7. uchar code arr[] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};

  9. uchar duanZhi[]= {0,0};//保存每段數(shù)碼管顯示位數(shù)的數(shù)值
  10. sbit P36=P3^6;//數(shù)碼管時能端
  11. sbit P37=P3^7;
  12. sbit ST=P3^0;//定義74HC595移位寄存器
  13. sbit SH=P3^2;
  14. sbit DS=P3^1;
  15. sbit P33=P3^3;
  16. sbit P34=P3^4;
  17. sbit P35=P3^5;

  19. uchar shi,ge;//數(shù)碼管個位和十位顯示
  20. uchar tmp;//暫存P0的值
  21. static uchar keynum=0;//按鍵值
  22. unsigned char Trg;
  23. unsigned char Cont;
  24. static char count=1;
  25. //毫秒級延時
  26. void delay(uint z)
  27. {
  28.     uint x,y;
  29.     for(x=z; x>>0; x--)
  30.         for(y=110; y>>0; y--);
  31. }
  32. void SendTo595(uchar byteData);
  33. int Search(uchar arr[], int len, int flag)
  34. {
  35.     int right = len - 1;
  36.     int left = 0;
  37.     while (left <= right)
  38.     {
  39.         int mid = (right + left) / 2;
  40.         if (arr[mid] > flag)
  41.         {
  42.             right = mid - 1;
  43.         }
  44.         else if (arr[mid] < flag)
  45.         {
  46.             left = mid + 1;
  47.         }
  48.         else
  49.         {
  50.             return arr[mid];
  51.         }
  52.     }
  53.     return 0;
  54. }
  55. /*----------------------------------------------------------------------------------
  56.                                 顯示

  58. void display2()
  59. {
  60.     ge = keynum%10;
  61.     shi = keynum/10;
  62.     duanZhi[0]=table[ge];
  63.     duanZhi[1]=table[shi];
  64.     P34=0x00;
  65.     SendTo595(duanZhi[0]);                 //
  66.     delay(5);
  67.     P34=0x01;//消隱

  69.     P33=0x00;
  70.     SendTo595(duanZhi[1]);//
  71.     delay(5);
  72.     P33=0x01;//消隱

  74. }
  75. ----------------------------------------------------------------------------------*/
  76. void display()
  77. {
  78.     ge = keynum%10;
  79.     shi = keynum/10;
  80.     duanZhi[0]=table[ge];
  81.     duanZhi[1]=table[shi];
  82.     //顯示個位
  83.     P37=0;
  84.     SendTo595(duanZhi[0]);                 //
  85.     delay(2);
  86.     P37=1;//消隱
  87.     //顯示十位
  88.     P36=0;
  89.     SendTo595(duanZhi[1]);//
  90.     delay(2);
  91.     P36=1;//消隱

  93. }
  94. /***********************************************************
  95. *函數(shù)名                ：SendTo595
  96. *功能                :串行發(fā)送8個比特（一個字節(jié)）的數(shù)據(jù)給595，再并行輸出
  97. *參數(shù)                ：byteData
  98. ************************************************************/
  99. void SendTo595(uchar byteData)
  100. {
  101.     uchar i=0;
  102.     ST = 0;   //ST //先拉低，為后面的上升沿做準備
  103.     for(i; i<8; i++)
  104.     {
  105.         SH = 0;//先拉低，
  106.         if(byteData&0x80)DS=1;
  107.         else DS=0;
  108. //        DS = (byteData&0x80)?1:0;
  109.         byteData = byteData <<1;                //該字節(jié)右移一位

  111.         SH = 1;//上升沿，讓串行輸入時鐘變?yōu)楦唠娖�，并延時2個時鐘周期
  112.         _nop_();
  113.         _nop_();
  114.         SH = 0;        //上升沿，讓串行輸入時鐘變?yōu)楦唠娖�，并延時2個時鐘周期
  115.     }
  116.     /*位移寄存器數(shù)據(jù)準備完畢,轉(zhuǎn)移到存儲寄存器*/
  117.     ST =1;
  118.     _nop_();
  119.     _nop_();
  120.     ST = 0;
  121. }

  123. void key_scan()
  124. {
  125. //    P0=0xff;
  126. //    delay(6);

  128.     /********************第1行掃描**************************/

  130.     P0=0x7F;//掃描第1行0111 1111
  131.     delay(5);
  132.     if (!Search(arr, 8, tmp))//有按鍵按下
  133.     {
  134.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  135.         switch(tmp)
  136.         {   //臨時變量對逐個IO口進行查詢
  137.         case 0x7e:
  138.             keynum=50;
  139.             break;//第1行第1個按鍵按下
  140.         case 0x7d:
  141.             keynum=51;
  142.             break;//第1行第2個按鍵按下
  143.         case 0x7b:
  144.             keynum=52;
  145.             break;//第1行第3個按鍵按下
  146.         case 0x77:
  147.             keynum=53;
  148.             break;//第1行第4個按鍵按下
  149.         case 0x6f:
  150.             keynum=54;
  151.             break;//第1行第5個按鍵按下
  152.         case 0x5f:
  153.             keynum=55;
  154.             break;//第1行第6個按鍵按下
  155.         case 0x3f:
  156.             keynum=56;
  157.             break;//第1行第7個按鍵按下
  158.         }
  159.     }
  160.     /********************第2行掃描**************************/
  161.     P0=0xbf;//掃描第2行
  162.     delay(5);
  163.     if(P0!=0xbf)//有按鍵按下
  164.     {
  165.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  166.         switch(tmp)
  167.         {   //臨時變量對逐個IO口進行查詢
  168.         case 0xbe:
  169.             keynum=43;
  170.             break;//第2行第1個按鍵按下
  171.         case 0xbd:
  172.             keynum=44;
  173.             break;//第2行第2個按鍵按下
  174.         case 0xbb:
  175.             keynum=45;
  176.             break;//第2行第3個按鍵按下
  177.         case 0xb7:
  178.             keynum=46;
  179.             break;//第2行第4個按鍵按下
  180.         case 0xaf:
  181.             keynum=47;
  182.             break;//第2行第5個按鍵按下
  183.         case 0x9f:
  184.             keynum=48;
  185.             break;//第2行第6個按鍵按下
  186.         case 0x3f:
  187.             keynum=49;
  188.             break;//第2行第7個按鍵按下
  189.         }        
  190.     }
  191.     /********************第3行掃描**************************/

  193.     P0=0xdf;//掃描第3行
  194.     delay(5);
  195.      if(P0!=0xdf)//有按鍵按下
  196.     {
  197.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  198.         switch(tmp)
  199.         {   //臨時變量對逐個IO口進行查詢
  200.         case 0xde:
  201.             keynum=36;
  202.             break;//第3行第1個按鍵按下
  203.         case 0xdd:
  204.             keynum=37;
  205.             break;//第3行第2個按鍵按下
  206.         case 0xdb:
  207.             keynum=38;
  208.             break;//第3行第3個按鍵按下
  209.         case 0xd7:
  210.             keynum=39;
  211.             break;//第3行第4個按鍵按下
  212.         case 0xcf:
  213.             keynum=40;
  214.             break;//第3行第5個按鍵按下
  215.         case 0x9f:
  216.             keynum=41;
  217.             break;//第3行第6個按鍵按下
  218.         case 0x5f:
  219.             keynum=42;
  220.             break;//第3行第7個按鍵按下
  221.         }

  223.     }
  224.     /********************第4行掃描**************************/

  226.     P0=0xef;//掃描第4行
  227.     delay(5);
  228.     if(P0!=0xef)//有按鍵按下
  229.     {
  230.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  231.         switch(tmp)
  232.         {   //臨時變量對逐個IO口進行查詢
  233.         case 0xee:
  234.             keynum=29;
  235.             break;//第4行第1個按鍵按下
  236.         case 0xed:
  237.             keynum=30;
  238.             break;//第4行第2個按鍵按下
  239.         case 0xeb:
  240.             keynum=31;
  241.             break;//第4行第3個按鍵按下
  242.         case 0xe7:
  243.             keynum=32;
  244.             break;//第3行第4個按鍵按下
  245.         case 0xcf:
  246.             keynum=33;
  247.             break;//第4行第5個按鍵按下
  248.         case 0xaf:
  249.             keynum=34;
  250.             break;//第4行第6個按鍵按下
  251.         case 0x6f:
  252.             keynum=35;
  253.             break;//第4行第7個按鍵按下
  254.         }               
  255.     }
  256.     /********************第5行掃描**************************/

  258.     P0=0xf7;//掃描第5行
  259.     delay(5);
  260.     if(P0!=0xf7)//有按鍵按下
  261.     {
  262.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  263.         switch(tmp)
  264.         {   //臨時變量對逐個IO口進行查詢
  265.         case 0xf6:
  266.             keynum=22;
  267.             break;//第5行第1個按鍵按下
  268.         case 0xf5:
  269.             keynum=23;
  270.             break;//第5行第2個按鍵按下
  271.         case 0xf3:
  272.             keynum=24;
  273.             break;//第5行第3個按鍵按下
  274.         case 0xe7:
  275.             keynum=25;
  276.             break;//第5行第4個按鍵按下
  277.         case 0xd7:
  278.             keynum=26;
  279.             break;//第5行第5個按鍵按下
  280.         case 0xb7:
  281.             keynum=27;
  282.             break;//第5行第6個按鍵按下
  283.         case 0x77:
  284.             keynum=28;
  285.             break;//第5行第7個按鍵按下
  286.         }               
  287.     }
  288.     /********************第6行掃描**************************/

  290.     P0=0xfb;//掃描第6行
  291.     delay(5);
  292.     if(P0!=0xfb)//有按鍵按下
  293.     {
  294.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  295.         switch(tmp)
  296.         {   //臨時變量對逐個IO口進行查詢
  297.         case 0xfa:
  298.             keynum=15;
  299.             break;//第6行第1個按鍵按下
  300.         case 0xf9:
  301.             keynum=16;
  302.             break;//第6行第2個按鍵按下
  303.         case 0xf3:
  304.             keynum=17;
  305.             break;//第6行第3個按鍵按下
  306.         case 0xeb:
  307.             keynum=18;
  308.             break;//第6行第4個按鍵按下
  309.         case 0xdb:
  310.             keynum=19;
  311.             break;//第6行第5個按鍵按下
  312.         case 0xbb:
  313.             keynum=20;
  314.             break;//第6行第6個按鍵按下
  315.         case 0x7b:
  316.             keynum=21;
  317.             break;//第6行第7個按鍵按下
  318.         }
  319.     }
  320.     /********************第7行掃描**************************/
  321.     P0=0xfd;//掃描第7行
  322.     delay(5);
  323.     if(P0!=0xfd)//有按鍵按下
  324.     {
  325.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  326.         switch(tmp)
  327.         {   //臨時變量對逐個IO口進行查詢
  328.         case 0xfc:
  329.             keynum=8;
  330.             break;//第7行第1個按鍵按下
  331.         case 0xf9:
  332.             keynum=9;
  333.             break;//第7行第2個按鍵按下
  334.         case 0xf5:
  335.             keynum=10;
  336.             break;//第7行第3個按鍵按下
  337.         case 0xed:
  338.             keynum=11;
  339.             break;//第7行第4個按鍵按下
  340.         case 0xdd:
  341.             keynum=12;
  342.             break;//第7行第5個按鍵按下
  343.         case 0xbd:
  344.             keynum=13;
  345.             break;//第7行第6個按鍵按下
  346.         case 0x7d:
  347.             keynum=14;
  348.             break;//第7行第7個按鍵按下
  349.         }
  350.     }
  351.     /********************第8行掃描**************************/

  353.     P0=0xfe;//掃描第8行
  354.     delay(5);
  355.     if(P0!=0xfe)//有按鍵按下
  356.     {
  357.         tmp=P0;//將檢測到的P0狀態(tài)值賦值給臨時變量
  358.         switch(tmp)
  359.         {   //臨時變量對逐個IO口進行查詢
  360.         case 0xfc:
  361.             keynum=1;
  362.             break;//第8行第1個按鍵按下
  363.         case 0xfa:
  364.             keynum=2;
  365.             break;//第8行第2個按鍵按下
  366.         case 0xf6:
  367.             keynum=3;
  368.             break;//第8行第3個按鍵按下
  369.         case 0xee:
  370.             keynum=4;
  371.             break;//第8行第4個按鍵按下
  372.         case 0xde:
  373.             keynum=5;
  374.             break;//第8行第5個按鍵按下
  375.         case 0xbe:
  376.             keynum=6;
  377.             break;//第8行第6個按鍵按下
  378.         case 0x7e:
  379.             keynum=7;
  380.             break;//第8行第7個按鍵按下
  381.         }
  382.     }
  383. /****************自身端口讀取*********************/
  384.                 P0=0xff;//掃描第8行
  385. //    delay(5);
  386.                 tmp=P0;
  387.     if (Search(arr, 8, tmp))
  388.     {
  389.         //將檢測到的P0狀態(tài)值賦值給臨時變量
  390.         switch(Search(arr, 8, tmp))
  391.         {   //臨時變量對逐個IO口進行查詢
  392.         case 0xfe:
  393.             keynum=57;
  394.             break;//第1行第1個按鍵按下
  395.         case 0xfd:
  396.             keynum=58;
  397.             break;//第1行第2個按鍵按下
  398.         case 0xfb:
  399.             keynum=59;
  400.             break;//第1行第3個按鍵按下
  401.         case 0xf7:
  402.             keynum=60;
  403.             break;//第1行第4個按鍵按下
  404.         case 0xef:
  405.             keynum=61;
  406.             break;//第1行第5個按鍵按下
  407.         case 0xdf:
  408.             keynum=62;
  409.             break;//第1行第6個按鍵按下
  410.         case 0xbf:
  411.             keynum=63;
  412.             break;//第1行第7個按鍵按下
  413.         case 0x7f:
  414.             keynum=64;
  415.             break;//第1行第8個按鍵按下
  416.         }        
  417.                         display();//這里必須單獨處理P0的IO檢測和顯示，否則容易跳數(shù)
  418.                         delay(80);//阻塞按鍵掃描，防止數(shù)碼管跳變，其他行掃描不需要此處的延時。
  419.     }
  420.    display();//這里的顯示是保存上一次的顯示值

  422. }
  423. void main()
  424. {
  425.     keynum=0;
  426.     P0=0xff;
  427.     while(1)
  428.     {               
  429.         key_scan();
  430.     }
  431. }
復制代碼
仿真器件選選擇也是很有講究的。附上截圖







我會附上源碼，提供兩套不同實現(xiàn)方案的代碼。
8個IO口檢測64個按鍵.zip (118.94 KB, 下載次數(shù): 42)


作者: cb474265474265    時間: 2021-9-12 07:51
感謝樓主的無私奉獻，下載學習了。
作者: lon7085    時間: 2021-9-12 09:14
感謝樓主的分享，學習了。
作者: 7631001    時間: 2021-9-12 10:14
樓主很厲害，辛苦了
作者: npn    時間: 2021-9-12 16:58
這個程序還可以優(yōu)化很多，仿真測試OK。
  1. #include "reg51.h"
  2. #include "intrins.h"
  3. #define u8 unsigned char
  4. sbit P36 = P3 ^ 6;
  5. sbit P37 = P3 ^ 7;
  6. sbit STCP = P3 ^ 0;//定義74HC595移位寄存器
  7. sbit SHCP = P3 ^ 2;
  8. sbit DS = P3 ^ 1;

  10. u8 code table[16] = {                //共陰數(shù)碼管段碼16進制
  11.         0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71
  12. };

  14. void delay(){
  15.     u8 a,b;
  16.     for(b=19;b>0;b--)
  17.         for(a=130;a>0;a--);
  18. }

  20. void txd595(u8 d) {
  21.         u8 i;
  22.         for (i = 0; i < 8; i++) {
  23.                 DS = d & 0x80;
  24.                 SHCP = 0;
  25.                 d <<= 1;
  26.                 SHCP = 1;
  27.         }
  28.         STCP=0;_nop_();STCP=1;
  29. }

  31. void display(u8 d) {
  32.         P37 = 0;
  33.         txd595(table[d%10]);
  34.         delay();
  35.         P37 = 1;
  36.         _nop_();
  37.         P36 = 0;
  38.         txd595(table[d/10]);
  39.         delay();
  40.         P36 = 1;
  41. }

  43. u8 b0(u8 dat) {                //取一個字節(jié)中有多少個二進制0 返回0~8
  44.         u8 i, j = 0;
  45.         for (i = 0; i < 8; i++) {
  46.                 if (!(dat & (1 << i))) {
  47.                         j++;
  48.                 }
  49.         }
  50.         return j;
  51. }

  53. u8 key_scan() {                //無按鍵返回0 有按鍵返回1~64 (禁止多個按鍵同時按下,出錯返回99)
  54.         u8 i, j, k, l, m;
  55.         P0 = 0xFF;
  56.         _nop_();
  57.         k = P0;
  58.         if (k != 0xFF) {
  59.                 if (b0(k) != 1) return 99;
  60.                 for (i = 0; i < 8; i++) {
  61.                         if (!(k & (1 << i))) {
  62.                                 return 57 + i;
  63.                         }
  64.                 }
  65.         }

  67.         for (i = 0; i < 8; i++) {
  68.                 j = ~(1 << i);
  69.                 P0 = j;
  70.                 _nop_();
  71.                 k= P0;
  72.                 if (k != j) {
  73.                         if (k & ~j || b0(k) != 2) return 99;
  74.                         m = 0;
  75.                         for (l = 0; l < 8; l++) {
  76.                                 if (i == l) continue;
  77.                                 m++;
  78.                                 if (!(k & (1 << l))) {
  79.                                         return i * 7 + m;
  80.                                 }
  81.                         }
  82.                 }

  84.         }
  85.         return 0;
  86. }

  88. void main() {
  89.         while (1) {
  90.                 display(key_scan());
  91.         }
  92. }
復制代碼
作者: 29417765    時間: 2021-9-12 17:03
不錯，這個例程好。IO不夠的時候，之前用過4個IO口實現(xiàn)16個按鍵的方法，和樓主的電路差不多。
作者: perseverance51    時間: 2021-9-16 10:33
npn 發(fā)表于 2021-9-12 16:58
這個程序還可以優(yōu)化很多，仿真測試OK。

感謝壇友的集思廣益，群策群力，在源代碼基礎上做的優(yōu)化和改進。



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